Performance improvements, Add BlockParser.Trigger

README.md

@@ -79,6 +79,25 @@ if err := goldmark.Convert(source, &buf); err != nil {
 }
 ```
 
+With options
+------------------------------
+
+```go
+var buf bytes.Buffer
+if err := goldmark.Convert(source, &buf, parser.WithWorkers(16)); err != nil {
+  panic(err)
+}
+```
+
+| Functional option | Type | Description |
+| ----------------- | ---- | ----------- |
+| `parser.WithContext` | A parser.Context | Context for the parsing phase. |
+|  parser.WithWorkers | int | Number of goroutines that execute concurrent inline element parsing. |
+
+`parser.WithWorkers` may make performance better a little if markdown text
+is relatively large. Otherwise, `parser.Workers` may cause performance degradation due to
+goroutine overheads.
+
 Custom parser and renderer
 --------------------------
 ```go
@@ -236,10 +255,16 @@ blackfriday v2 can not simply be compared with other Commonmark compliant librar
 Though goldmark builds clean extensible AST structure and get full compliance with 
 Commonmark, it is resonably fast and less memory consumption.
 
+This benchmark parses a relatively large markdown text. In such text, concurrent parsing
+makes performance better a little.
+
 ```
-BenchmarkGoldMark-4                  200           6388385 ns/op         2085552 B/op      13856 allocs/op
-BenchmarkGolangCommonMark-4          200           7056577 ns/op         2974119 B/op      18828 allocs/op
-BenchmarkBlackFriday-4               300           5635122 ns/op         3341668 B/op      20057 allocs/op
+BenchmarkMarkdown/Blackfriday-v2-4                   300           5316935 ns/op         3321072 B/op      20050 allocs/op
+BenchmarkMarkdown/GoldMark(workers=16)-4             300           5506219 ns/op         2702358 B/op      14494 allocs/op
+BenchmarkMarkdown/GoldMark-4                         200           5903779 ns/op         2594304 B/op      13861 allocs/op
+BenchmarkMarkdown/CommonMark-4                       200           7147659 ns/op         2752977 B/op      18827 allocs/op
+BenchmarkMarkdown/Lute-4                             200           5930621 ns/op         2839712 B/op      21165 allocs/op
+BenchmarkMarkdown/GoMarkdown-4                        10         120953070 ns/op         2192278 B/op      22174 allocs/op
 ```
 
 ### against cmark(A CommonMark reference implementation written in c)
@@ -248,12 +273,15 @@ BenchmarkBlackFriday-4               300           5635122 ns/op         3341668
 ----------- cmark -----------
 file: _data.md
 iteration: 50
-average: 0.0050112160 sec
-go run ./goldmark_benchmark.go
+average: 0.0047014618 sec
 ------- goldmark -------
 file: _data.md
 iteration: 50
-average: 0.0064833820 sec
+average: 0.0052624750 sec
+------- goldmark(workers=16) -------
+file: _data.md
+iteration: 50
+average: 0.0044918780 sec
 ```
 
 As you can see, goldmark performs pretty much equally to the cmark.

_benchmark/cmark/goldmark_benchmark.go

@@ -9,6 +9,7 @@ import (
 	"time"
 
 	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/renderer/html"
 )
 
@@ -42,4 +43,18 @@ func main() {
 	fmt.Printf("file: %s\n", file)
 	fmt.Printf("iteration: %d\n", n)
 	fmt.Printf("average: %.10f sec\n", float64((int64(sum)/int64(n)))/1000000000.0)
+
+	sum = time.Duration(0)
+	for i := 0; i < n; i++ {
+		start := time.Now()
+		out.Reset()
+		if err := markdown.Convert(source, &out, parser.WithWorkers(16)); err != nil {
+			panic(err)
+		}
+		sum += time.Since(start)
+	}
+	fmt.Printf("------- goldmark(workers=16) -------\n")
+	fmt.Printf("file: %s\n", file)
+	fmt.Printf("iteration: %d\n", n)
+	fmt.Printf("average: %.10f sec\n", float64((int64(sum)/int64(n)))/1000000000.0)
 }

_benchmark/go/benchmark_test.go

@@ -7,11 +7,15 @@ import (
 
 	gomarkdown "github.com/gomarkdown/markdown"
 	"github.com/yuin/goldmark"
+	"github.com/yuin/goldmark/parser"
 	"github.com/yuin/goldmark/renderer/html"
+	"github.com/yuin/goldmark/util"
 	"gitlab.com/golang-commonmark/markdown"
 
 	bf1 "github.com/russross/blackfriday"
 	bf2 "gopkg.in/russross/blackfriday.v2"
+
+	"github.com/b3log/lute"
 )
 
 func BenchmarkMarkdown(b *testing.B) {
@@ -31,13 +35,25 @@ func BenchmarkMarkdown(b *testing.B) {
 		doBenchmark(b, r)
 	})
 
+	b.Run("GoldMark(workers=16)", func(b *testing.B) {
+		markdown := goldmark.New(
+			goldmark.WithRendererOptions(html.WithXHTML(), html.WithUnsafe()),
+		)
+		r := func(src []byte) ([]byte, error) {
+			var out bytes.Buffer
+			err := markdown.Convert(src, &out, parser.WithWorkers(16))
+			return out.Bytes(), err
+		}
+		doBenchmark(b, r)
+	})
+
 	b.Run("GoldMark", func(b *testing.B) {
 		markdown := goldmark.New(
 			goldmark.WithRendererOptions(html.WithXHTML(), html.WithUnsafe()),
 		)
 		r := func(src []byte) ([]byte, error) {
 			var out bytes.Buffer
-			err := markdown.Convert(src, &out)
+			err := markdown.Convert(src, &out, parser.WithWorkers(0))
 			return out.Bytes(), err
 		}
 		doBenchmark(b, r)
@@ -53,13 +69,28 @@ func BenchmarkMarkdown(b *testing.B) {
 		doBenchmark(b, r)
 	})
 
+	b.Run("Lute", func(b *testing.B) {
+		luteEngine := lute.New(
+			lute.GFM(false),
+			lute.CodeSyntaxHighlight(false),
+			lute.SoftBreak2HardBreak(false),
+			lute.AutoSpace(false),
+			lute.FixTermTypo(false))
+		r := func(src []byte) ([]byte, error) {
+			out, err := luteEngine.FormatStr("Benchmark", util.BytesToReadOnlyString(src))
+			return util.StringToReadOnlyBytes(out), err
+		}
+		doBenchmark(b, r)
+	})
+
 	b.Run("GoMarkdown", func(b *testing.B) {
 		r := func(src []byte) ([]byte, error) {
 			out := gomarkdown.ToHTML(src, nil, nil)
 			return out, nil
 		}
 		doBenchmark(b, r)
 	})
+
 }
 
 // The different frameworks have different APIs. Create an adapter that

extension/definition_list.go

@@ -22,6 +22,10 @@ func NewDefinitionListParser() parser.BlockParser {
 	return defaultDefinitionListParser
 }
 
+func (b *definitionListParser) Trigger() []byte {
+	return []byte{':'}
+}
+
 func (b *definitionListParser) Open(parent gast.Node, reader text.Reader, pc parser.Context) (gast.Node, parser.State) {
 	if _, ok := parent.(*ast.DefinitionList); ok {
 		return nil, parser.NoChildren
@@ -105,6 +109,10 @@ func NewDefinitionDescriptionParser() parser.BlockParser {
 	return defaultDefinitionDescriptionParser
 }
 
+func (b *definitionDescriptionParser) Trigger() []byte {
+	return []byte{':'}
+}
+
 func (b *definitionDescriptionParser) Open(parent gast.Node, reader text.Reader, pc parser.Context) (gast.Node, parser.State) {
 	line, _ := reader.PeekLine()
 	pos := pc.BlockOffset()

extension/footnote.go

@@ -26,6 +26,10 @@ func NewFootnoteBlockParser() parser.BlockParser {
 	return defaultFootnoteBlockParser
 }
 
+func (b *footnoteBlockParser) Trigger() []byte {
+	return []byte{'['}
+}
+
 func (b *footnoteBlockParser) Open(parent gast.Node, reader text.Reader, pc parser.Context) (gast.Node, parser.State) {
 	line, segment := reader.PeekLine()
 	pos := pc.BlockOffset()
@@ -136,7 +140,7 @@ func (s *footnoteParser) Parse(parent gast.Node, block text.Reader, pc parser.Co
 	block.Advance(closes + 1)
 
 	var list *ast.FootnoteList
-	if tlist := pc.Get(footnoteListKey); tlist != nil {
+	if tlist := pc.Root().Get(footnoteListKey); tlist != nil {
 		list = tlist.(*ast.FootnoteList)
 	}
 	if list == nil {

parser/atx_heading.go

@@ -74,6 +74,10 @@ func NewATXHeadingParser(opts ...HeadingOption) BlockParser {
 	return p
 }
 
+func (b *atxHeadingParser) Trigger() []byte {
+	return []byte{'#'}
+}
+
 func (b *atxHeadingParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	line, segment := reader.PeekLine()
 	pos := pc.BlockOffset()

parser/blockquote.go

@@ -38,6 +38,10 @@ func (b *blockquoteParser) process(reader text.Reader) bool {
 	return true
 }
 
+func (b *blockquoteParser) Trigger() []byte {
+	return []byte{'>'}
+}
+
 func (b *blockquoteParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	if b.process(reader) {
 		return ast.NewBlockquote(), HasChildren

parser/code_block.go

@@ -18,6 +18,10 @@ func NewCodeBlockParser() BlockParser {
 	return defaultCodeBlockParser
 }
 
+func (b *codeBlockParser) Trigger() []byte {
+	return nil
+}
+
 func (b *codeBlockParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	line, segment := reader.PeekLine()
 	pos, padding := util.IndentPosition(line, reader.LineOffset(), 4)

parser/fcode_block.go

@@ -28,6 +28,10 @@ type fenceData struct {
 
 var fencedCodeBlockInfoKey = NewContextKey()
 
+func (b *fencedCodeBlockParser) Trigger() []byte {
+	return []byte{'~', '`'}
+}
+
 func (b *fencedCodeBlockParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	line, segment := reader.PeekLine()
 	pos := pc.BlockOffset()

parser/html_block.go

@@ -105,6 +105,10 @@ func NewHTMLBlockParser() BlockParser {
 	return defaultHtmlBlockParser
 }
 
+func (b *htmlBlockParser) Trigger() []byte {
+	return []byte{'<'}
+}
+
 func (b *htmlBlockParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	var node *ast.HTMLBlock
 	line, segment := reader.PeekLine()

parser/link.go

@@ -169,7 +169,7 @@ func (s *linkParser) Parse(parent ast.Node, block text.Reader, pc Context) ast.N
 		block.SetPosition(l, pos)
 		ssegment := text.NewSegment(last.Segment.Stop, segment.Start)
 		maybeReference := block.Value(ssegment)
-		ref, ok := pc.Reference(util.ToLinkReference(maybeReference))
+		ref, ok := pc.Root().Reference(util.ToLinkReference(maybeReference))
 		if !ok {
 			ast.MergeOrReplaceTextSegment(last.Parent(), last, last.Segment)
 			return nil
@@ -243,7 +243,7 @@ func (s *linkParser) parseReferenceLink(parent ast.Node, last *linkLabelState, b
 		maybeReference = block.Value(ssegment)
 	}
 
-	ref, ok := pc.Reference(util.ToLinkReference(maybeReference))
+	ref, ok := pc.Root().Reference(util.ToLinkReference(maybeReference))
 	if !ok {
 		return nil, true
 	}

parser/list.go

@@ -116,6 +116,10 @@ func NewListParser() BlockParser {
 	return defaultListParser
 }
 
+func (b *listParser) Trigger() []byte {
+	return []byte{'-', '+', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
+}
+
 func (b *listParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	last := pc.LastOpenedBlock().Node
 	if _, lok := last.(*ast.List); lok || pc.Get(skipListParser) != nil {

parser/list_item.go

@@ -20,6 +20,10 @@ func NewListItemParser() BlockParser {
 var skipListParser = NewContextKey()
 var skipListParserValue interface{} = true
 
+func (b *listItemParser) Trigger() []byte {
+	return []byte{'-', '+', '*', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9'}
+}
+
 func (b *listItemParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	list, lok := parent.(*ast.List)
 	if !lok { // list item must be a child of a list

parser/paragraph.go

@@ -16,6 +16,10 @@ func NewParagraphParser() BlockParser {
 	return defaultParagraphParser
 }
 
+func (b *paragraphParser) Trigger() []byte {
+	return nil
+}
+
 func (b *paragraphParser) Open(parent ast.Node, reader text.Reader, pc Context) (ast.Node, State) {
 	_, segment := reader.PeekLine()
 	segment = segment.TrimLeftSpace(reader.Source())