WordPress.org

Make WordPress Core

Changeset 36566


Ignore:
Timestamp:
02/17/2016 10:57:33 PM (2 years ago)
Author:
boonebgorges
Message:

More performance improvements to metadata lazyloading.

Comment and term meta lazyloading for WP_Query loops, introduced in 4.4,
depended on filter callback methods belonging to WP_Query objects. This meant
storing WP_Query objects in the $wp_filter global (via add_filter()),
requiring that PHP retain the objects in memory, even when the local variables
would typically be expunged during normal garbage collection. In cases where a
large number of WP_Query objects were instantiated on a single pageload,
and/or where the contents of the WP_Query objects were quite large, serious
performance issues could result.

We skirt this problem by moving metadata lazyloading out of WP_Query. The
new WP_Metadata_Lazyloader class acts as a lazyload queue. Query instances
register items whose metadata should be lazyloaded - such as post terms, or
comments - and a WP_Metadata_Lazyloader method will intercept comment and
term meta requests to perform the cache priming. Since WP_Metadata_Lazyloader
instances are far smaller than WP_Query (containing only object IDs), and
clean up after themselves far better than the previous WP_Query methods (bp
only running their callbacks a single time for a given set of queued objects),
the resource use is decreased dramatically.

See [36525] for an earlier step in this direction.

Props lpawlik, stevegrunwell, boonebgorges.
Fixes #35816.

Location:
trunk
Files:
1 added
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/wp-includes/comment-template.php

    r36527 r36566  
    13931393     */
    13941394    $wp_query->comments = apply_filters( 'comments_array', $comments_flat, $post->ID );
    1395 
    1396     // Set up lazy-loading for comment metadata.
    1397     add_action( 'get_comment_metadata', array( $wp_query, 'lazyload_comment_meta' ), 10, 2 );
    13981395
    13991396    $comments = &$wp_query->comments;
     
    20302027    if ( null === $r['reverse_top_level'] )
    20312028        $r['reverse_top_level'] = ( 'desc' == get_option('comment_order') );
     2029
     2030    wp_queue_comments_for_comment_meta_lazyload( $_comments );
    20322031
    20332032    if ( empty( $r['walker'] ) ) {
  • trunk/src/wp-includes/comment.php

    r36542 r36566  
    470470
    471471/**
     472 * Queue comments for metadata lazyloading.
     473 *
     474 * @since 4.5.0
     475 *
     476 * @param array $comments Array of comment objects.
     477 */
     478function wp_queue_comments_for_comment_meta_lazyload( $comments ) {
     479    // Don't use `wp_list_pluck()` to avoid by-reference manipulation.
     480    $comment_ids = array();
     481    if ( is_array( $comments ) ) {
     482        foreach ( $comments as $comment ) {
     483            if ( $comment instanceof WP_Comment ) {
     484                $comment_ids[] = $comment->comment_ID;
     485            }
     486        }
     487    }
     488
     489    if ( $comment_ids ) {
     490        $lazyloader = wp_metadata_lazyloader();
     491        $lazyloader->queue_objects( 'comment', $comment_ids );
     492    }
     493}
     494
     495/**
    472496 * Sets the cookies used to store an unauthenticated commentator's identity. Typically used
    473497 * to recall previous comments by this commentator that are still held in moderation.
  • trunk/src/wp-includes/meta.php

    r36511 r36566  
    853853
    854854/**
     855 * Get the metadata lazyloading queue.
     856 *
     857 * @since 4.5.0
     858 *
     859 * @return WP_Metadata_Lazyloader $lazyloader Metadata lazyloader queue.
     860 */
     861function wp_metadata_lazyloader() {
     862    static $wp_metadata_lazyloader;
     863
     864    if ( null === $wp_metadata_lazyloader ) {
     865        $wp_metadata_lazyloader = new WP_Metadata_Lazyloader();
     866    }
     867
     868    return $wp_metadata_lazyloader;
     869}
     870
     871/**
    855872 * Given a meta query, generates SQL clauses to be appended to a main query.
    856873 *
  • trunk/src/wp-includes/post.php

    r36498 r36566  
    59495949
    59505950/**
     5951 * Queue posts for lazyloading of term meta.
     5952 *
     5953 * @since 4.5.0
     5954 *
     5955 * @param array $posts Array of WP_Post objects.
     5956 */
     5957function wp_queue_posts_for_term_meta_lazyload( $posts ) {
     5958    $post_type_taxonomies = $term_ids = array();
     5959    foreach ( $posts as $post ) {
     5960        if ( ! ( $post instanceof WP_Post ) ) {
     5961            continue;
     5962        }
     5963
     5964        if ( ! isset( $post_type_taxonomies[ $post->post_type ] ) ) {
     5965            $post_type_taxonomies[ $post->post_type ] = get_object_taxonomies( $post->post_type );
     5966        }
     5967
     5968        foreach ( $post_type_taxonomies[ $post->post_type ] as $taxonomy ) {
     5969            // Term cache should already be primed by `update_post_term_cache()`.
     5970            $terms = get_object_term_cache( $post->ID, $taxonomy );
     5971            if ( false !== $terms ) {
     5972                foreach ( $terms as $term ) {
     5973                    if ( ! isset( $term_ids[ $term->term_id ] ) ) {
     5974                        $term_ids[] = $term->term_id;
     5975                    }
     5976                }
     5977            }
     5978        }
     5979    }
     5980
     5981    if ( $term_ids ) {
     5982        $lazyloader = wp_metadata_lazyloader();
     5983        $lazyloader->queue_objects( 'term', $term_ids );
     5984    }
     5985}
     5986
     5987/**
    59515988 * Update the custom taxonomies' term counts when a post's status is changed.
    59525989 *
  • trunk/src/wp-includes/query.php

    r36524 r36566  
    36063606            $this->posts = array_map( 'get_post', $this->posts );
    36073607
    3608 
    3609         if ( $q['update_post_term_cache'] ) {
    3610             add_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
    3611         }
    3612 
    36133608        if ( ! $q['suppress_filters'] ) {
    36143609            /**
     
    37393734        // If comments have been fetched as part of the query, make sure comment meta lazy-loading is set up.
    37403735        if ( ! empty( $this->comments ) ) {
    3741             add_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
     3736            wp_queue_comments_for_comment_meta_lazyload( $this->comments );
    37423737        }
    37433738
     
    37693764            $this->post_count = 0;
    37703765            $this->posts = array();
     3766        }
     3767
     3768        if ( $q['update_post_term_cache'] ) {
     3769            wp_queue_posts_for_term_meta_lazyload( $this->posts );
    37713770        }
    37723771
     
    48354834
    48364835    /**
    4837      * Lazy-loads termmeta for located posts.
    4838      *
    4839      * As a rule, term queries (`get_terms()` and `wp_get_object_terms()`) prime the metadata cache for matched
    4840      * terms by default. However, this can cause a slight performance penalty, especially when that metadata is
    4841      * not actually used. In the context of a `WP_Query` instance, we're able to avoid this potential penalty.
    4842      * `update_object_term_cache()`, called from `update_post_caches()`, does not 'update_term_meta_cache'.
    4843      * Instead, the first time `get_term_meta()` is called from within a `WP_Query` loop, the current method
    4844      * detects the fact, and then primes the metadata cache for all terms attached to all posts in the loop,
    4845      * with a single database query.
    4846      *
    4847      * This method is public so that it can be used as a filter callback. As a rule, there is no need to invoke it
    4848      * directly, from either inside or outside the `WP_Query` object.
     4836     * Lazyload term meta for posts in the loop.
    48494837     *
    48504838     * @since 4.4.0
    4851      * @access public
    4852      *
    4853      * @param mixed $check  The `$check` param passed from the 'get_term_metadata' hook.
    4854      * @param int  $term_id ID of the term whose metadata is being cached.
    4855      * @return mixed In order not to short-circuit `get_metadata()`. Generally, this is `null`, but it could be
    4856      *               another value if filtered by a plugin.
     4839     * @deprecated 4.5.0 See wp_queue_posts_for_term_meta_lazyload().
     4840     *
     4841     * @param mixed $check
     4842     * @param int   $term_id
     4843     * @return mixed
    48574844     */
    48584845    public function lazyload_term_meta( $check, $term_id ) {
    4859         // We can only lazyload if the entire post object is present.
    4860         $posts = array();
    4861         foreach ( $this->posts as $post ) {
    4862             if ( $post instanceof WP_Post ) {
    4863                 $posts[] = $post;
    4864             }
    4865         }
    4866 
    4867         if ( ! empty( $posts ) ) {
    4868             // Fetch cached term_ids for each post. Keyed by term_id for faster lookup.
    4869             $term_ids = array();
    4870             foreach ( $posts as $post ) {
    4871                 $taxonomies = get_object_taxonomies( $post->post_type );
    4872                 foreach ( $taxonomies as $taxonomy ) {
    4873                     // Term cache should already be primed by 'update_post_term_cache'.
    4874                     $terms = get_object_term_cache( $post->ID, $taxonomy );
    4875                     if ( false !== $terms ) {
    4876                         foreach ( $terms as $term ) {
    4877                             if ( ! isset( $term_ids[ $term->term_id ] ) ) {
    4878                                 $term_ids[ $term->term_id ] = 1;
    4879                             }
    4880                         }
    4881                     }
    4882                 }
    4883             }
    4884 
    4885             /*
    4886              * Only update the metadata cache for terms belonging to these posts if the term_id passed
    4887              * to `get_term_meta()` matches one of those terms. This prevents a single call to
    4888              * `get_term_meta()` from priming metadata for all `WP_Query` objects.
    4889              */
    4890             if ( isset( $term_ids[ $term_id ] ) ) {
    4891                 update_termmeta_cache( array_keys( $term_ids ) );
    4892                 remove_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
    4893             }
    4894         }
    4895 
    4896         // If no terms were found, there's no need to run this again.
    4897         if ( empty( $term_ids ) ) {
    4898             remove_filter( 'get_term_metadata', array( $this, 'lazyload_term_meta' ), 10, 2 );
    4899         }
    4900 
     4846        _deprecated_function( __METHOD__, '4.5.0' );
    49014847        return $check;
    49024848    }
    49034849
    49044850    /**
    4905      * Lazy-load comment meta when inside of a `WP_Query` loop.
    4906      *
    4907      * This method is public so that it can be used as a filter callback. As a rule, there is no need to invoke it
    4908      * directly, from either inside or outside the `WP_Query` object.
     4851     * Lazyload comment meta for comments in the loop.
    49094852     *
    49104853     * @since 4.4.0
    4911      *
    4912      * @param mixed $check     The `$check` param passed from the 'get_comment_metadata' hook.
    4913      * @param int  $comment_id ID of the comment whose metadata is being cached.
    4914      * @return mixed The original value of `$check`, to not affect 'get_comment_metadata'.
     4854     * @deprecated 4.5.0 See wp_queue_comments_for_comment_meta_lazyload().
     4855     *
     4856     * @param mixed $check
     4857     * @param int   $comment_id
     4858     * @return mixed
    49154859     */
    49164860    public function lazyload_comment_meta( $check, $comment_id ) {
    4917         // Don't use `wp_list_pluck()` to avoid by-reference manipulation.
    4918         $comment_ids = array();
    4919         if ( is_array( $this->comments ) ) {
    4920             foreach ( $this->comments as $comment ) {
    4921                 $comment_ids[] = $comment->comment_ID;
    4922             }
    4923         }
    4924 
    4925         /*
    4926          * Only update the metadata cache for comments belonging to these posts if the comment_id passed
    4927          * to `get_comment_meta()` matches one of those comments. This prevents a single call to
    4928          * `get_comment_meta()` from priming metadata for all `WP_Query` objects.
    4929          */
    4930         if ( in_array( $comment_id, $comment_ids ) ) {
    4931             update_meta_cache( 'comment', $comment_ids );
    4932             remove_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
    4933         } elseif ( empty( $comment_ids ) ) {
    4934             remove_filter( 'get_comment_metadata', array( $this, 'lazyload_comment_meta' ), 10, 2 );
    4935         }
    4936 
     4861        _deprecated_function( __METHOD__, '4.5.0' );
    49374862        return $check;
    49384863    }
  • trunk/src/wp-settings.php

    r36557 r36566  
    136136require( ABSPATH . WPINC . '/meta.php' );
    137137require( ABSPATH . WPINC . '/class-wp-meta-query.php' );
     138require( ABSPATH . WPINC . '/class-wp-metadata-lazyloader.php' );
    138139require( ABSPATH . WPINC . '/general-template.php' );
    139140require( ABSPATH . WPINC . '/link-template.php' );
  • trunk/tests/phpunit/tests/term/meta.php

    r35585 r36566  
    135135                $num_queries = $wpdb->num_queries;
    136136                $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
    137                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     137                $num_queries++;
     138                $this->assertSame( $num_queries, $wpdb->num_queries );
    138139
    139140                // Second and third requests should be in cache.
    140141                $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
    141142                $this->assertSame( 'bar', get_term_meta( $terms[2], 'foo', true ) );
    142                 $this->assertSame( $num_queries + 1, $wpdb->num_queries );
     143                $this->assertSame( $num_queries, $wpdb->num_queries );
    143144
    144145                // Querying a term not primed should result in a hit.
     146                $num_queries++;
    145147                $this->assertSame( 'bar', get_term_meta( $orphan_term, 'foo', true ) );
    146                 $this->assertSame( $num_queries + 2, $wpdb->num_queries );
     148                $this->assertSame( $num_queries, $wpdb->num_queries );
    147149            }
    148150        }
    149151    }
    150152
    151     /**
    152      * @ticket 34073
    153      */
    154     public function test_term_meta_should_be_lazy_loaded_only_for_the_queries_in_which_the_term_has_posts() {
    155         global $wpdb;
    156 
    157         $posts = self::factory()->post->create_many( 3, array( 'post_status' => 'publish' ) );
    158         register_taxonomy( 'wptests_tax', 'post' );
    159         $terms = self::factory()->term->create_many( 6, array( 'taxonomy' => 'wptests_tax' ) );
    160 
    161         wp_set_object_terms( $posts[0], array( $terms[0], $terms[1] ), 'wptests_tax' );
    162         wp_set_object_terms( $posts[1], array( $terms[2], $terms[3] ), 'wptests_tax' );
    163         wp_set_object_terms( $posts[2], array( $terms[0], $terms[4], $terms[5] ), 'wptests_tax' );
    164 
    165         foreach ( $terms as $t ) {
    166             add_term_meta( $t, 'foo', 'bar' );
    167         }
    168 
    169         $q0 = new WP_Query( array( 'p' => $posts[0], 'cache_results' => true ) );
    170         $q1 = new WP_Query( array( 'p' => $posts[1], 'cache_results' => true ) );
    171         $q2 = new WP_Query( array( 'p' => $posts[2], 'cache_results' => true ) );
    172 
    173         /*
    174          * $terms[0] belongs to both $posts[0] and $posts[2], so `get_term_meta( $terms[0] )` should prime
    175          * the cache for term matched by $q0 and $q2.
    176          */
    177 
    178         // First request will hit the database.
    179         $num_queries = $wpdb->num_queries;
    180 
    181         // Prime caches.
    182         $this->assertSame( 'bar', get_term_meta( $terms[0], 'foo', true ) );
    183 
    184         // Two queries: one for $q0 and one for $q2.
    185         $num_queries += 2;
    186         $this->assertSame( $num_queries, $wpdb->num_queries );
    187 
    188         // Next requests should be in cache.
    189         $this->assertSame( 'bar', get_term_meta( $terms[1], 'foo', true ) );
    190         $this->assertSame( 'bar', get_term_meta( $terms[4], 'foo', true ) );
    191         $this->assertSame( 'bar', get_term_meta( $terms[5], 'foo', true ) );
    192         $this->assertSame( $num_queries, $wpdb->num_queries );
    193 
    194         // Querying for $terms[2] will prime $terms[3] as well.
    195         $this->assertSame( 'bar', get_term_meta( $terms[2], 'foo', true ) );
    196         $num_queries++;
    197         $this->assertSame( $num_queries, $wpdb->num_queries );
    198 
    199         $this->assertSame( 'bar', get_term_meta( $terms[3], 'foo', true ) );
    200         $this->assertSame( $num_queries, $wpdb->num_queries );
    201     }
    202 
    203     public function test_adding_term_meta_should_bust_get_terms_cache() {
     153    public function test_updating_term_meta_should_bust_get_terms_cache() {
    204154        $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    205155
    206156        add_term_meta( $terms[0], 'foo', 'bar' );
     157        add_term_meta( $terms[1], 'foo', 'baz' );
    207158
    208159        // Prime cache.
     
    220171        $this->assertEqualSets( array( $terms[0] ), $found );
    221172
    222         add_term_meta( $terms[1], 'foo', 'bar' );
     173        update_term_meta( $terms[1], 'foo', 'bar' );
    223174
    224175        $found = get_terms( 'wptests_tax', array(
     
    236187    }
    237188
    238     public function test_updating_term_meta_should_bust_get_terms_cache() {
     189    public function test_deleting_term_meta_should_bust_get_terms_cache() {
    239190        $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    240191
    241192        add_term_meta( $terms[0], 'foo', 'bar' );
    242         add_term_meta( $terms[1], 'foo', 'baz' );
     193        add_term_meta( $terms[1], 'foo', 'bar' );
    243194
    244195        // Prime cache.
     
    254205        ) );
    255206
    256         $this->assertEqualSets( array( $terms[0] ), $found );
    257 
    258         update_term_meta( $terms[1], 'foo', 'bar' );
     207        $this->assertEqualSets( array( $terms[0], $terms[1] ), $found );
     208
     209        delete_term_meta( $terms[1], 'foo', 'bar' );
    259210
    260211        $found = get_terms( 'wptests_tax', array(
     
    269220        ) );
    270221
    271         $this->assertEqualSets( array( $terms[0], $terms[1] ), $found );
    272     }
    273 
    274     public function test_deleting_term_meta_should_bust_get_terms_cache() {
    275         $terms = self::factory()->term->create_many( 2, array( 'taxonomy' => 'wptests_tax' ) );
    276 
    277         add_term_meta( $terms[0], 'foo', 'bar' );
    278         add_term_meta( $terms[1], 'foo', 'bar' );
    279 
    280         // Prime cache.
    281         $found = get_terms( 'wptests_tax', array(
    282             'hide_empty' => false,
    283             'fields' => 'ids',
    284             'meta_query' => array(
    285                 array(
    286                     'key' => 'foo',
    287                     'value' => 'bar',
    288                 ),
    289             ),
    290         ) );
    291 
    292         $this->assertEqualSets( array( $terms[0], $terms[1] ), $found );
    293 
    294         delete_term_meta( $terms[1], 'foo', 'bar' );
    295 
    296         $found = get_terms( 'wptests_tax', array(
    297             'hide_empty' => false,
    298             'fields' => 'ids',
    299             'meta_query' => array(
    300                 array(
    301                     'key' => 'foo',
    302                     'value' => 'bar',
    303                 ),
    304             ),
    305         ) );
    306 
    307222        $this->assertEqualSets( array( $terms[0] ), $found );
    308223    }
Note: See TracChangeset for help on using the changeset viewer.