Merge pull request #97 from goccy/feature/fix-interface

Fix interface operation and optimize map operation

Author: goccy

benchmarks/encode_test.go

@@ -472,3 +472,68 @@ func Benchmark_Encode_LargeStructCached_GoJsonNoEscape(b *testing.B) {
 		}
 	}
 }
+
+func benchMapValue() map[string]interface{} {
+	return map[string]interface{}{
+		"a": 1,
+		"b": 2.1,
+		"c": "hello",
+		"d": struct {
+			V int
+		}{
+			V: 1,
+		},
+		"e": true,
+	}
+}
+
+func Benchmark_Encode_MapInterface_EncodingJson(b *testing.B) {
+	v := benchMapValue()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		if _, err := json.Marshal(v); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func Benchmark_Encode_MapInterface_JsonIter(b *testing.B) {
+	v := benchMapValue()
+	var json = jsoniter.ConfigCompatibleWithStandardLibrary
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		if _, err := json.Marshal(v); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func Benchmark_Encode_MapInterface_Jettison(b *testing.B) {
+	v := benchMapValue()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		if _, err := jettison.Marshal(v); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func Benchmark_Encode_MapInterface_SegmentioJson(b *testing.B) {
+	v := benchMapValue()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		if _, err := segmentiojson.Marshal(v); err != nil {
+			b.Fatal(err)
+		}
+	}
+}
+
+func Benchmark_Encode_MapInterface_GoJson(b *testing.B) {
+	v := benchMapValue()
+	b.ReportAllocs()
+	for i := 0; i < b.N; i++ {
+		if _, err := gojson.Marshal(v); err != nil {
+			b.Fatal(err)
+		}
+	}
+}

cmd/generator/main.go

@@ -315,7 +315,6 @@ func (t opType) fieldToStringTagField() opType {
 	opTypes := []opType{
 		createOpType("End", "Op"),
 		createOpType("Interface", "Op"),
-		createOpType("InterfaceEnd", "Op"),
 		createOpType("Ptr", "Op"),
 		createOpType("NPtr", "Op"),
 		createOpType("SliceHead", "SliceHead"),

encode.go

@@ -22,6 +22,7 @@ type Encoder struct {
 	enabledIndent     bool
 	enabledHTMLEscape bool
 	unorderedMap      bool
+	baseIndent        int
 	prefix            []byte
 	indentStr         []byte
 }
@@ -112,6 +113,7 @@ func (e *Encoder) EncodeWithOption(v interface{}, opts ...EncodeOption) error {
 		}
 	}
 	header := (*interfaceHeader)(unsafe.Pointer(&v))
+	e.ptr = header.ptr
 	buf, err := e.encode(header, v == nil)
 	if err != nil {
 		return err
@@ -155,6 +157,7 @@ func (e *Encoder) release() {
 }
 
 func (e *Encoder) reset() {
+	e.baseIndent = 0
 	e.enabledHTMLEscape = true
 	e.enabledIndent = false
 	e.unorderedMap = false
@@ -192,23 +195,31 @@ func (e *Encoder) encode(header *interfaceHeader, isNil bool) ([]byte, error) {
 	typ := header.typ
 
 	typeptr := uintptr(unsafe.Pointer(typ))
-	opcodeMap := loadOpcodeMap()
-	if codeSet, exists := opcodeMap[typeptr]; exists {
-		ctx := e.ctx
-		p := uintptr(header.ptr)
-		ctx.init(p, codeSet.codeLength)
+	codeSet, err := e.compileToGetCodeSet(typeptr)
+	if err != nil {
+		return nil, err
+	}
 
-		if e.enabledIndent {
-			if e.enabledHTMLEscape {
-				return e.runEscapedIndent(ctx, b, codeSet.code)
-			} else {
-				return e.runIndent(ctx, b, codeSet.code)
-			}
-		}
+	ctx := e.ctx
+	p := uintptr(header.ptr)
+	ctx.init(p, codeSet.codeLength)
+	if e.enabledIndent {
 		if e.enabledHTMLEscape {
-			return e.runEscaped(ctx, b, codeSet.code)
+			return e.runEscapedIndent(ctx, b, codeSet)
+		} else {
+			return e.runIndent(ctx, b, codeSet)
 		}
-		return e.run(ctx, b, codeSet.code)
+	}
+	if e.enabledHTMLEscape {
+		return e.runEscaped(ctx, b, codeSet)
+	}
+	return e.run(ctx, b, codeSet)
+}
+
+func (e *Encoder) compileToGetCodeSet(typeptr uintptr) (*opcodeSet, error) {
+	opcodeMap := loadOpcodeMap()
+	if codeSet, exists := opcodeMap[typeptr]; exists {
+		return codeSet, nil
 	}
 
 	// noescape trick for header.typ ( reflect.*rtype )
@@ -230,21 +241,7 @@ func (e *Encoder) encode(header *interfaceHeader, isNil bool) ([]byte, error) {
 	}
 
 	storeOpcodeSet(typeptr, codeSet, opcodeMap)
-	p := uintptr(header.ptr)
-	ctx := e.ctx
-	ctx.init(p, codeLength)
-
-	if e.enabledIndent {
-		if e.enabledHTMLEscape {
-			return e.runEscapedIndent(ctx, b, codeSet.code)
-		} else {
-			return e.runIndent(ctx, b, codeSet.code)
-		}
-	}
-	if e.enabledHTMLEscape {
-		return e.runEscaped(ctx, b, codeSet.code)
-	}
-	return e.run(ctx, b, codeSet.code)
+	return codeSet, nil
 }
 
 func encodeFloat32(b []byte, v float32) []byte {
@@ -303,7 +300,7 @@ func appendStructEnd(b []byte) []byte {
 func (e *Encoder) appendStructEndIndent(b []byte, indent int) []byte {
 	b = append(b, '\n')
 	b = append(b, e.prefix...)
-	b = append(b, bytes.Repeat(e.indentStr, indent)...)
+	b = append(b, bytes.Repeat(e.indentStr, e.baseIndent+indent)...)
 	return append(b, '}', ',', '\n')
 }
 
@@ -324,5 +321,5 @@ func encodeByteSlice(b []byte, src []byte) []byte {
 
 func (e *Encoder) encodeIndent(b []byte, indent int) []byte {
 	b = append(b, e.prefix...)
-	return append(b, bytes.Repeat(e.indentStr, indent)...)
+	return append(b, bytes.Repeat(e.indentStr, e.baseIndent+indent)...)
 }

encode_context.go

@@ -1,9 +1,67 @@
 package json
 
 import (
+	"bytes"
+	"sync"
 	"unsafe"
 )
 
+type mapItem struct {
+	key   []byte
+	value []byte
+}
+
+type mapslice struct {
+	items []mapItem
+}
+
+func (m *mapslice) Len() int {
+	return len(m.items)
+}
+
+func (m *mapslice) Less(i, j int) bool {
+	return bytes.Compare(m.items[i].key, m.items[j].key) < 0
+}
+
+func (m *mapslice) Swap(i, j int) {
+	m.items[i], m.items[j] = m.items[j], m.items[i]
+}
+
+type encodeMapContext struct {
+	iter  unsafe.Pointer
+	pos   []int
+	slice *mapslice
+	buf   []byte
+}
+
+var mapContextPool = sync.Pool{
+	New: func() interface{} {
+		return &encodeMapContext{}
+	},
+}
+
+func newMapContext(mapLen int) *encodeMapContext {
+	ctx := mapContextPool.Get().(*encodeMapContext)
+	if ctx.slice == nil {
+		ctx.slice = &mapslice{
+			items: make([]mapItem, 0, mapLen),
+		}
+	}
+	if cap(ctx.pos) < (mapLen*2 + 1) {
+		ctx.pos = make([]int, 0, mapLen*2+1)
+		ctx.slice.items = make([]mapItem, 0, mapLen)
+	} else {
+		ctx.pos = ctx.pos[:0]
+		ctx.slice.items = ctx.slice.items[:0]
+	}
+	ctx.buf = ctx.buf[:0]
+	return ctx
+}
+
+func releaseMapContext(c *encodeMapContext) {
+	mapContextPool.Put(c)
+}
+
 type encodeCompileContext struct {
 	typ                      *rtype
 	root                     bool

encode_opcode.go

@@ -131,7 +131,7 @@ func (c *opcode) totalLength() int {
 	var idx int
 	for code := c; code.op != opEnd; {
 		idx = int(code.idx / uintptrSize)
-		if code.op == opInterfaceEnd || code.op == opStructFieldRecursiveEnd {
+		if code.op == opStructFieldRecursiveEnd {
 			break
 		}
 		switch code.op.codeType() {