Re: [patch] mm: speedup in __early_pfn_to_nid

[Yinghai Lu]

On Sat, Mar 23, 2013 at 8:29 AM, Russ Anderson <rja@xxxxxxx> wrote:
> On Fri, Mar 22, 2013 at 08:25:32AM +0100, Ingo Molnar wrote:
> ------------------------------------------------------------
> When booting on a large memory system, the kernel spends
> considerable time in memmap_init_zone() setting up memory zones.
> Analysis shows significant time spent in __early_pfn_to_nid().
>
> The routine memmap_init_zone() checks each PFN to verify the
> nid is valid.  __early_pfn_to_nid() sequentially scans the list of
> pfn ranges to find the right range and returns the nid.  This does
> not scale well.  On a 4 TB (single rack) system there are 308
> memory ranges to scan.  The higher the PFN the more time spent
> sequentially spinning through memory ranges.
>
> Since memmap_init_zone() increments pfn, it will almost always be
> looking for the same range as the previous pfn, so check that
> range first.  If it is in the same range, return that nid.
> If not, scan the list as before.
>
> A 4 TB (single rack) UV1 system takes 512 seconds to get through
> the zone code.  This performance optimization reduces the time
> by 189 seconds, a 36% improvement.
>
> A 2 TB (single rack) UV2 system goes from 212.7 seconds to 99.8 seconds,
> a 112.9 second (53%) reduction.

Interesting. but only have 308 entries in memblock...

Did you try to extend memblock_search() to search nid back?
Something like attached patch. That should save more time.

>
> Signed-off-by: Russ Anderson <rja@xxxxxxx>
> ---
>  arch/ia64/mm/numa.c |   15 ++++++++++++++-
>  mm/page_alloc.c     |   15 ++++++++++++++-
>  2 files changed, 28 insertions(+), 2 deletions(-)
>
> Index: linux/mm/page_alloc.c
> ===================================================================
> --- linux.orig/mm/page_alloc.c  2013-03-19 16:09:03.736450861 -0500
> +++ linux/mm/page_alloc.c       2013-03-22 17:07:43.895405617 -0500
> @@ -4161,10 +4161,23 @@ int __meminit __early_pfn_to_nid(unsigne
>  {
>         unsigned long start_pfn, end_pfn;
>         int i, nid;
> +       /*
> +          NOTE: The following SMP-unsafe globals are only used early
> +          in boot when the kernel is running single-threaded.
> +        */
> +       static unsigned long last_start_pfn, last_end_pfn;
> +       static int last_nid;
> +
> +       if (last_start_pfn <= pfn && pfn < last_end_pfn)
> +               return last_nid;
>
>         for_each_mem_pfn_range(i, MAX_NUMNODES, &start_pfn, &end_pfn, &nid)
> -               if (start_pfn <= pfn && pfn < end_pfn)
> +               if (start_pfn <= pfn && pfn < end_pfn) {
> +                       last_start_pfn = start_pfn;
> +                       last_end_pfn = end_pfn;
> +                       last_nid = nid;
>                         return nid;
> +               }
>         /* This is a memory hole */
>         return -1;
>  }
> Index: linux/arch/ia64/mm/numa.c
> ===================================================================
> --- linux.orig/arch/ia64/mm/numa.c      2013-02-25 15:49:44.000000000 -0600
> +++ linux/arch/ia64/mm/numa.c   2013-03-22 16:09:44.662268239 -0500
> @@ -61,13 +61,26 @@ paddr_to_nid(unsigned long paddr)
>  int __meminit __early_pfn_to_nid(unsigned long pfn)
>  {
>         int i, section = pfn >> PFN_SECTION_SHIFT, ssec, esec;
> +       /*
> +          NOTE: The following SMP-unsafe globals are only used early
> +          in boot when the kernel is running single-threaded.
> +       */
> +       static unsigned long last_start_pfn, last_end_pfn;

last_ssec, last_esec?


> +       static int last_nid;
> +
> +       if (section >= last_ssec && section < last_esec)
> +               return last_nid;
>
>         for (i = 0; i < num_node_memblks; i++) {
>                 ssec = node_memblk[i].start_paddr >> PA_SECTION_SHIFT;
>                 esec = (node_memblk[i].start_paddr + node_memblk[i].size +
>                         ((1L << PA_SECTION_SHIFT) - 1)) >> PA_SECTION_SHIFT;
> -               if (section >= ssec && section < esec)
> +               if (section >= ssec && section < esec) {
> +                       last_ssec = ssec;
> +                       last_esec = esec;
> +                       last_nid = node_memblk[i].nid
>                         return node_memblk[i].nid;
> +               }
>         }
>
>         return -1;
>

also looks like you forget to put IA maintainers in the To list.

may just put ia64 part in separated patch?

Thanks

Yinghai

Attachment: memblock_search_pfn_nid.patch
Description: Binary data