speed improvements and a bug fix

cmd/goxdr/goxdr.go

@@ -494,7 +494,7 @@ func (r *rpc_const) emit(e *emitter) {
 	if r.comment != "" {
 		e.printf("%s\n", r.comment)
 	}
-	// Replace the character '\'' with '_' in r.val before printing constants; 
+	// Replace the character '\'' with '_' in r.val before printing constants;
 	// golang supports _ but not '
 	valStr := strings.ReplaceAll(r.val.String(), "'", "_")
 	e.printf("const %s = %s\n", r.id, valStr)
@@ -1386,7 +1386,6 @@ func main() {
 
 	if *opt_emitbp {
 		fmt.Fprintf(out, `import(
-	"bytes"
 	"context"
 	"encoding/binary"
 	"fmt"

cmd/goxdr/header.go.in

@@ -665,16 +665,18 @@ func (xo XdrOut) Marshal(name string, i XdrType) {
 }
 
 func xdrReadN(in io.Reader, n uint32) []byte {
-	var b bytes.Buffer
-	if _, err := io.CopyN(&b, in, int64(n)); err != nil {
-		XdrPanic("%s", err.Error())
+	p := make([]byte, n)
+	if k, err := io.ReadFull(in, p); err != nil {
+		XdrPanic("short read; %d/%d bytes (%s)", k, n, err.Error())
 	}
-	return b.Bytes()
+	return p
 }
 
 func xdrReadPad(in io.Reader, n uint32) {
 	if n & 3 != 0 {
-		got := xdrReadN(in, 4-(n&3))
+		var buf [4]byte
+		got := buf[:4-(n&3)]
+		xdrReadInto(in, got)
 		for _, b := range got {
 			if b != 0 {
 				XdrPanic("padding contained non-zero bytes")
@@ -683,17 +685,24 @@ func xdrReadPad(in io.Reader, n uint32) {
 	}
 }
 
+func xdrReadInto(in io.Reader, p []byte) {
+	if k, err := in.Read(p); err != nil || k != len(p) {
+		XdrPanic("%s", err.Error())
+	}
+}
+
 func xdrGet32(in io.Reader) uint32 {
-	b := xdrReadN(in, 4)
-	return binary.BigEndian.Uint32(b)
+	var b [4]byte
+	xdrReadInto(in, b[:])
+	return binary.BigEndian.Uint32(b[:])
 }
 
 func xdrGet64(in io.Reader) uint64 {
-	b := xdrReadN(in, 8)
-	return binary.BigEndian.Uint64(b)
+	var b [8]byte
+	xdrReadInto(in, b[:])
+	return binary.BigEndian.Uint64(b[:])
 }
 
-
 // XDR that unmarshals from canonical binary format
 type XdrIn struct {
 	In io.Reader

rpc/callpool.go

@@ -0,0 +1,66 @@
+package rpc
+
+import "github.com/xdrpp/goxdr/xdr"
+
+type CallPool interface {
+	NewCall() *PendingCall
+	Recycle(*PendingCall)
+	StatString() string
+}
+
+// arena
+
+type callArena struct {
+	arena *xdr.Arena[PendingCall]
+}
+
+func NewCallArena(cap int) CallPool {
+	callArena := &callArena{}
+	callArena.arena = xdr.NewArena(
+		cap,
+		func(p *PendingCall) {
+			*p = PendingCall{}
+		},
+	)
+	return callArena
+}
+
+func (callArena *callArena) StatString() string {
+	return callArena.arena.StatString()
+}
+
+func (callArena *callArena) NewCall() *PendingCall {
+	return callArena.arena.Get()
+}
+
+func (callArena *callArena) Recycle(call *PendingCall) {
+	callArena.arena.Recycle(call)
+}
+
+// pool
+
+type callPool struct {
+	pool *xdr.Pool[PendingCall]
+}
+
+func NewCallPool() CallPool {
+	x := &callPool{}
+	x.pool = xdr.NewPool(
+		func(call *PendingCall) {
+			*call = PendingCall{}
+		},
+	)
+	return x
+}
+
+func (callPool *callPool) NewCall() *PendingCall {
+	return callPool.pool.Get()
+}
+
+func (callPool *callPool) Recycle(call *PendingCall) {
+	callPool.pool.Recycle(call)
+}
+
+func (callPool *callPool) StatString() string {
+	return callPool.pool.StatString()
+}