Skip to content
Permalink
Browse files

resources/page: Use binary search in Pages.Prev/Next if possible

This is obviously much faster for lager data sets:

```bash
name                         old time/op    new time/op    delta
SearchPage/ByWeight-100-4       267ns ± 4%     272ns ± 5%     ~     (p=0.457 n=4+4)
SearchPage/ByWeight-5000-4     10.8µs ± 3%     1.2µs ± 2%  -88.99%  (p=0.029 n=4+4)
SearchPage/ByWeight-10000-4    21.1µs ± 1%     1.4µs ±11%  -93.28%  (p=0.029 n=4+4)
```

See #4500
  • Loading branch information...
bep committed Oct 11, 2019
1 parent f4f566e commit 653e6856ea1cfc60cc16733807d23b302dbe4bd5
@@ -63,7 +63,7 @@ func BenchmarkPagesPrevNext(b *testing.B) {
Variant{"Pages.Shuffled.Prev", shufflePages, func(p page.Page, pages page.Pages) { pages.Prev(p) }},
Variant{"Pages.ByTitle.Next", func(pages page.Pages) page.Pages { return pages.ByTitle() }, func(p page.Page, pages page.Pages) { pages.Next(p) }},
} {
for _, numPages := range []int{100, 300, 900, 5000} {
for _, numPages := range []int{300, 5000} {
b.Run(fmt.Sprintf("%s-pages-%d", variant.name, numPages), func(b *testing.B) {
b.StopTimer()
builder := newPagesPrevNextTestSite(b, numPages)
@@ -15,26 +15,21 @@ package page

// Next returns the next page reletive to the given
func (p Pages) Next(cur Page) Page {
for x, c := range p {
if c.Eq(cur) {
if x == 0 {
return nil
}
return p[x-1]
}
x := searchPage(cur, p)
if x <= 0 {
return nil
}
return nil
return p[x-1]
}

// Prev returns the previous page reletive to the given
func (p Pages) Prev(cur Page) Page {
for x, c := range p {
if c.Eq(cur) {
if x < len(p)-1 {
return p[x+1]
}
return nil
}
x := searchPage(cur, p)

if x == -1 || len(p)-x < 2 {
return nil
}
return nil

return p[x+1]

}
@@ -46,59 +46,78 @@ func (by pageBy) Sort(pages Pages) {
sort.Stable(ps)
}

// DefaultPageSort is the default sort func for pages in Hugo:
// Order by Weight, Date, LinkTitle and then full file path.
var DefaultPageSort = func(p1, p2 Page) bool {
if p1.Weight() == p2.Weight() {
if p1.Date().Unix() == p2.Date().Unix() {
c := compare.Strings(p1.LinkTitle(), p2.LinkTitle())
if c == 0 {
if p1.File().IsZero() || p2.File().IsZero() {
return p1.File().IsZero()
var (

// DefaultPageSort is the default sort func for pages in Hugo:
// Order by Weight, Date, LinkTitle and then full file path.
DefaultPageSort = func(p1, p2 Page) bool {
if p1.Weight() == p2.Weight() {
if p1.Date().Unix() == p2.Date().Unix() {
c := compare.Strings(p1.LinkTitle(), p2.LinkTitle())
if c == 0 {
if p1.File().IsZero() || p2.File().IsZero() {
return p1.File().IsZero()
}
return compare.LessStrings(p1.File().Filename(), p2.File().Filename())
}
return compare.LessStrings(p1.File().Filename(), p2.File().Filename())
return c < 0
}
return c < 0
return p1.Date().Unix() > p2.Date().Unix()
}
return p1.Date().Unix() > p2.Date().Unix()
}

if p2.Weight() == 0 {
return true
}
if p2.Weight() == 0 {
return true
}

if p1.Weight() == 0 {
return false
}
if p1.Weight() == 0 {
return false
}

return p1.Weight() < p2.Weight()
}
return p1.Weight() < p2.Weight()
}

var languagePageSort = func(p1, p2 Page) bool {
lessPageLanguage = func(p1, p2 Page) bool {

if p1.Language().Weight == p2.Language().Weight {
if p1.Date().Unix() == p2.Date().Unix() {
c := compare.Strings(p1.LinkTitle(), p2.LinkTitle())
if c == 0 {
if !p1.File().IsZero() && !p2.File().IsZero() {
return compare.LessStrings(p1.File().Filename(), p2.File().Filename())
if p1.Language().Weight == p2.Language().Weight {
if p1.Date().Unix() == p2.Date().Unix() {
c := compare.Strings(p1.LinkTitle(), p2.LinkTitle())
if c == 0 {
if !p1.File().IsZero() && !p2.File().IsZero() {
return compare.LessStrings(p1.File().Filename(), p2.File().Filename())
}
}
return c < 0
}
return c < 0
return p1.Date().Unix() > p2.Date().Unix()
}
return p1.Date().Unix() > p2.Date().Unix()

if p2.Language().Weight == 0 {
return true
}

if p1.Language().Weight == 0 {
return false
}

return p1.Language().Weight < p2.Language().Weight
}

if p2.Language().Weight == 0 {
return true
lessPageTitle = func(p1, p2 Page) bool {
return compare.LessStrings(p1.Title(), p2.Title())
}

if p1.Language().Weight == 0 {
return false
lessPageLinkTitle = func(p1, p2 Page) bool {
return compare.LessStrings(p1.LinkTitle(), p2.LinkTitle())
}

return p1.Language().Weight < p2.Language().Weight
}
lessPageDate = func(p1, p2 Page) bool {
return p1.Date().Unix() < p2.Date().Unix()
}

lessPagePubDate = func(p1, p2 Page) bool {
return p1.PublishDate().Unix() < p2.PublishDate().Unix()
}
)

func (ps *pageSorter) Len() int { return len(ps.pages) }
func (ps *pageSorter) Swap(i, j int) { ps.pages[i], ps.pages[j] = ps.pages[j], ps.pages[i] }
@@ -139,11 +158,7 @@ func (p Pages) ByTitle() Pages {

const key = "pageSort.ByTitle"

title := func(p1, p2 Page) bool {
return compare.LessStrings(p1.Title(), p2.Title())
}

pages, _ := spc.get(key, pageBy(title).Sort, p)
pages, _ := spc.get(key, pageBy(lessPageTitle).Sort, p)
return pages
}

@@ -156,11 +171,7 @@ func (p Pages) ByLinkTitle() Pages {

const key = "pageSort.ByLinkTitle"

linkTitle := func(p1, p2 Page) bool {
return compare.LessStrings(p1.LinkTitle(), p2.LinkTitle())
}

pages, _ := spc.get(key, pageBy(linkTitle).Sort, p)
pages, _ := spc.get(key, pageBy(lessPageLinkTitle).Sort, p)

return pages
}
@@ -174,11 +185,7 @@ func (p Pages) ByDate() Pages {

const key = "pageSort.ByDate"

date := func(p1, p2 Page) bool {
return p1.Date().Unix() < p2.Date().Unix()
}

pages, _ := spc.get(key, pageBy(date).Sort, p)
pages, _ := spc.get(key, pageBy(lessPageDate).Sort, p)

return pages
}
@@ -192,11 +199,7 @@ func (p Pages) ByPublishDate() Pages {

const key = "pageSort.ByPublishDate"

pubDate := func(p1, p2 Page) bool {
return p1.PublishDate().Unix() < p2.PublishDate().Unix()
}

pages, _ := spc.get(key, pageBy(pubDate).Sort, p)
pages, _ := spc.get(key, pageBy(lessPagePubDate).Sort, p)

return pages
}
@@ -276,14 +279,14 @@ func (p Pages) ByLanguage() Pages {

const key = "pageSort.ByLanguage"

pages, _ := spc.get(key, pageBy(languagePageSort).Sort, p)
pages, _ := spc.get(key, pageBy(lessPageLanguage).Sort, p)

return pages
}

// SortByLanguage sorts the pages by language.
func SortByLanguage(pages Pages) {
pageBy(languagePageSort).Sort(pages)
pageBy(lessPageLanguage).Sort(pages)
}

// Reverse reverses the order in Pages and returns a copy.
@@ -0,0 +1,126 @@
// Copyright 2019 The Hugo Authors. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

package page

import "sort"

// Used in page binary search, the most common in front.
var pageLessFunctions = []func(p1, p2 Page) bool{
DefaultPageSort,
lessPageDate,
lessPagePubDate,
lessPageTitle,
lessPageLinkTitle,
}

func searchPage(p Page, pages Pages) int {
if len(pages) < 1000 {
// For smaller data sets, doing a linear search is faster.
return searchPageLinear(p, pages, 0)
}

less := isPagesProbablySorted(pages, pageLessFunctions...)
if less == nil {
return searchPageLinear(p, pages, 0)
}

i := searchPageBinary(p, pages, less)
if i != -1 {
return i
}

return searchPageLinear(p, pages, 0)
}

func searchPageLinear(p Page, pages Pages, start int) int {
for i := start; i < len(pages); i++ {
c := pages[i]
if c.Eq(p) {
return i
}
}
return -1
}

func searchPageBinary(p Page, pages Pages, less func(p1, p2 Page) bool) int {
n := len(pages)

f := func(i int) bool {
c := pages[i]
isLess := less(c, p)
return !isLess || c.Eq(p)
}

i := sort.Search(n, f)

if i == n {
return -1
}

return searchPageLinear(p, pages, i)

}

// isProbablySorted tests if the pages slice is probably sorted.
func isPagesProbablySorted(pages Pages, lessFuncs ...func(p1, p2 Page) bool) func(p1, p2 Page) bool {
n := len(pages)
step := 1
if n > 500 {
step = 50
}

is := func(less func(p1, p2 Page) bool) bool {
samples := 0

for i := n - 1; i > 0; i = i - step {
if less(pages[i], pages[i-1]) {
return false
}
samples++
if samples >= 15 {
return true
}
}
return samples > 0
}

isReverse := func(less func(p1, p2 Page) bool) bool {
samples := 0

for i := 0; i < n-1; i = i + step {
if less(pages[i], pages[i+1]) {
return false
}
samples++

if samples > 15 {
return true
}
}
return samples > 0
}

for _, less := range lessFuncs {
if is(less) {
return less
}
if isReverse(less) {
return func(p1, p2 Page) bool {
return less(p2, p1)
}
}
}

return nil
}

0 comments on commit 653e685

Please sign in to comment.
You can’t perform that action at this time.