small performance increase

benchmark_test.go

+package jrpc
+
+import (
+	"testing"
+
+	"golang.org/x/sync/errgroup"
+)
+
+func BenchmarkClientHTTPEcho(b *testing.B) {
+	server := newTestServer()
+	defer server.Stop()
+	client, hs := httpTestClient(server, "http", nil)
+	defer hs.Close()
+	defer client.Close()
+
+	// Launch concurrent requests.
+	wantBack := map[string]any{
+		"one": map[string]any{"two": "three"},
+		"e":   map[string]any{"two": "three"},
+		"oe":  map[string]any{"two": "three"},
+		"on":  map[string]any{"two": "three"},
+	}
+
+	b.StartTimer()
+	for n := 0; n < b.N; n++ {
+		eg := &errgroup.Group{}
+		for i := 0; i < 1000; i++ {
+			eg.Go(func() error {
+				return client.Call(nil, "test_echoAny", []any{1, 2, 3, 4, 56, 6, wantBack, wantBack, wantBack})
+			})
+		}
+		eg.Wait()
+	}
+}
+func BenchmarkClientHTTPEchoEmpty(b *testing.B) {
+	server := newTestServer()
+	defer server.Stop()
+	client, hs := httpTestClient(server, "http", nil)
+	defer hs.Close()
+	defer client.Close()
+
+	// Launch concurrent requests.
+
+	b.StartTimer()
+	for n := 0; n < b.N; n++ {
+		eg := &errgroup.Group{}
+		for i := 0; i < 1000; i++ {
+			eg.Go(func() error {
+				return client.Call(nil, "test_echoAny", 0)
+			})
+		}
+		eg.Wait()
+	}
+}
+func BenchmarkClientWebsocketEcho(b *testing.B) {
+	server := newTestServer()
+	defer server.Stop()
+	client, hs := httpTestClient(server, "ws", nil)
+	defer hs.Close()
+	defer client.Close()
+
+	// Launch concurrent requests.
+	wantBack := map[string]any{
+		"one": map[string]any{"two": "three"},
+		"e":   map[string]any{"two": "three"},
+		"oe":  map[string]any{"two": "three"},
+		"on":  map[string]any{"two": "three"},
+	}
+
+	b.StartTimer()
+	for n := 0; n < b.N; n++ {
+		eg := &errgroup.Group{}
+		for i := 0; i < 1000; i++ {
+			eg.Go(func() error {
+				return client.Call(nil, "test_echoAny", []any{1, 2, 3, 4, 56, 6, wantBack, wantBack, wantBack})
+			})
+		}
+		eg.Wait()
+	}
+
+}
+func BenchmarkClientWebsocketEchoEmpty(b *testing.B) {
+	server := newTestServer()
+	defer server.Stop()
+	client, hs := httpTestClient(server, "ws", nil)
+	defer hs.Close()
+	defer client.Close()
+
+	// Launch concurrent requests.
+	b.StartTimer()
+
+	for n := 0; n < b.N; n++ {
+		eg := &errgroup.Group{}
+		for i := 0; i < 1000; i++ {
+			eg.Go(func() error {
+				return client.Call(nil, "test_echoAny", 0)
+			})
+		}
+		eg.Wait()
+	}
+}

client_test.go

@@ -18,7 +18,6 @@ package jrpc
 
 import (
 	"context"
-	"encoding/json"
 	"fmt"
 	"math/rand"
 	"net"
@@ -335,86 +334,6 @@ func TestClientHTTP(t *testing.T) {
 	}
 }
 
-func BenchmarkClientHTTPEcho(b *testing.B) {
-	server := newTestServer()
-	defer server.Stop()
-	client, hs := httpTestClient(server, "http", nil)
-	defer hs.Close()
-	defer client.Close()
-
-	// Launch concurrent requests.
-	b.StartTimer()
-	wantBack := map[string]any{
-		"one": map[string]any{"two": "three"},
-		"e":   map[string]any{"two": "three"},
-		"oe":  map[string]any{"two": "three"},
-		"on":  map[string]any{"two": "three"},
-	}
-	var res json.RawMessage
-	for n := 0; n < b.N; n++ {
-		for i := 0; i < 100; i++ {
-			err := client.Call(&res, "test_echoAny", []any{1, 2, 3, 4, 56, 6, wantBack, wantBack, wantBack})
-			if err != nil {
-				panic(err)
-			}
-		}
-	}
-}
-func BenchmarkClientHTTPEchoEmpty(b *testing.B) {
-	server := newTestServer()
-	defer server.Stop()
-	client, hs := httpTestClient(server, "http", nil)
-	defer hs.Close()
-	defer client.Close()
-
-	// Launch concurrent requests.
-	b.StartTimer()
-	var res json.RawMessage
-	for n := 0; n < b.N; n++ {
-		for i := 0; i < 100; i++ {
-			client.Call(&res, "test_echoAny", 0)
-		}
-	}
-}
-func BenchmarkClientWebsocketEcho(b *testing.B) {
-	server := newTestServer()
-	defer server.Stop()
-	client, hs := httpTestClient(server, "ws", nil)
-	defer hs.Close()
-	defer client.Close()
-
-	// Launch concurrent requests.
-	b.StartTimer()
-	wantBack := map[string]any{
-		"one": map[string]any{"two": "three"},
-		"e":   map[string]any{"two": "three"},
-		"oe":  map[string]any{"two": "three"},
-		"on":  map[string]any{"two": "three"},
-	}
-	var res json.RawMessage
-	for n := 0; n < b.N; n++ {
-		for i := 0; i < 100; i++ {
-			client.Call(&res, "test_echoAny", []any{1, 2, 3, 4, 56, 6, wantBack, wantBack, wantBack})
-		}
-	}
-}
-func BenchmarkClientWebsocketEchoEmpty(b *testing.B) {
-	server := newTestServer()
-	defer server.Stop()
-	client, hs := httpTestClient(server, "ws", nil)
-	defer hs.Close()
-	defer client.Close()
-
-	// Launch concurrent requests.
-	b.StartTimer()
-	var res json.RawMessage
-	for n := 0; n < b.N; n++ {
-		for i := 0; i < 100; i++ {
-			client.Call(&res, "test_echoAny", 0)
-		}
-	}
-}
-
 func TestClientReconnect(t *testing.T) {
 	startServer := func(addr string) (*Server, net.Listener) {
 		srv := newTestServer()

go.mod

@@ -14,6 +14,7 @@ require (
 	github.com/imdario/mergo v0.3.13
 	github.com/json-iterator/go v1.1.12
 	github.com/test-go/testify v1.1.4
+	golang.org/x/sync v0.0.0-20210220032951-036812b2e83c
 	gopkg.in/natefinch/npipe.v2 v2.0.0-20160621034901-c1b8fa8bdcce
 	nhooyr.io/websocket v1.8.7
 	sigs.k8s.io/yaml v1.3.0

json.go

@@ -24,11 +24,13 @@ import (
 	"fmt"
 	"io"
 	"reflect"
+	"strconv"
 	"strings"
 	"sync"
 	"time"
 
 	"gfx.cafe/open/jrpc/wsjson"
+	jsoniter "github.com/json-iterator/go"
 )
 
 var jzon = wsjson.JZON
@@ -143,7 +145,7 @@ type JsonError = jsonError
 
 func (err *jsonError) Error() string {
 	if err.Message == "" {
-		return fmt.Sprintf("json-rpc error %d", err.Code)
+		return "json-rpc error " + strconv.Itoa(err.Code)
 	}
 	return err.Message
 }
@@ -298,18 +300,13 @@ func isBatch(raw json.RawMessage) bool {
 // given types. It returns the parsed values or an error when the args could not be
 // parsed. Missing optional arguments are returned as reflect.Zero values.
 func parsePositionalArguments(rawArgs json.RawMessage, types []reflect.Type) ([]reflect.Value, error) {
-	dec := json.NewDecoder(bytes.NewReader(rawArgs))
 	var args []reflect.Value
-	tok, err := dec.Token()
 	switch {
-	case err == io.EOF || tok == nil && err == nil:
-		// "params" is optional and may be empty. Also allow "params":null even though it's
-		// not in the spec because our own client used to send it.
-	case err != nil:
-		return nil, err
-	case tok == json.Delim('['):
+	case len(rawArgs) == 0:
+	case rawArgs[0] == '[':
 		// Read argument array.
-		if args, err = parseArgumentArray(dec, types); err != nil {
+		var err error
+		if args, err = parseArgumentArray(rawArgs, types); err != nil {
 			return nil, err
 		}
 	default:
@@ -325,14 +322,17 @@ func parsePositionalArguments(rawArgs json.RawMessage, types []reflect.Type) ([]
 	return args, nil
 }
 
-func parseArgumentArray(dec *json.Decoder, types []reflect.Type) ([]reflect.Value, error) {
+func parseArgumentArray(p json.RawMessage, types []reflect.Type) ([]reflect.Value, error) {
+	dec := jsoniter.NewIterator(jzon)
+	dec.ResetBytes(p)
 	args := make([]reflect.Value, 0, len(types))
-	for i := 0; dec.More(); i++ {
+	for i := 0; dec.ReadArray(); i++ {
 		if i >= len(types) {
 			return args, fmt.Errorf("too many arguments, want at most %d", len(types))
 		}
 		argval := reflect.New(types[i])
-		if err := dec.Decode(argval.Interface()); err != nil {
+		dec.ReadVal(argval.Interface())
+		if err := dec.Error; err != nil {
 			return args, fmt.Errorf("invalid argument %d: %v", i, err)
 		}
 		if argval.IsNil() && types[i].Kind() != reflect.Ptr {
@@ -340,9 +340,7 @@ func parseArgumentArray(dec *json.Decoder, types []reflect.Type) ([]reflect.Valu
 		}
 		args = append(args, argval.Elem())
 	}
-	// Read end of args array.
-	_, err := dec.Token()
-	return args, err
+	return args, nil
 }
 
 // parseSubscriptionName extracts the subscription name from an encoded argument array.