perf(gnolang): make print+println much more efficient

This change is the result of seeing print/println being
reported in bugs as needing gas metering but on examination,
noticed that the code causes a RAM and CPU bloat, so this
makes an improvement in all dimensions by invoking:
* io.WriteString(m.Output, segments) instead of m.Output.Write([]byte(segments))
* in cases where `!debug`, we don't need to construct the concatenated
  string delimited by " " and can instead write the Sprint-ed string
segments as we encounter them

```shell
$ benchstat before_println.txt after_println3.txt
name          old time/op    new time/op    delta
GnoPrintln-8    1.94ms ± 2%    1.86ms ± 4%   -4.02%  (p=0.001 n=9+9)

name          old alloc/op   new alloc/op   delta
GnoPrintln-8    1.92MB ± 0%    1.81MB ± 0%   -5.92%  (p=0.000 n=10+10)

name          old allocs/op  new allocs/op  delta
GnoPrintln-8     19.0k ± 0%     16.0k ± 0%  -15.76%  (p=0.002 n=8+10)
```

Fixes #3951

Author: odeke-em

gnovm/pkg/gnolang/native_perf_and_test.go

@@ -0,0 +1,147 @@
+package gnolang
+
+import (
+	"bytes"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+
+	"github.com/gnolang/gno/gnovm"
+	"github.com/gnolang/gno/tm2/pkg/db/memdb"
+	"github.com/gnolang/gno/tm2/pkg/store/dbadapter"
+	"github.com/gnolang/gno/tm2/pkg/store/iavl"
+	stypes "github.com/gnolang/gno/tm2/pkg/store/types"
+)
+
+var pSink any = nil
+
+func BenchmarkGnoPrintln(b *testing.B) {
+	var buf bytes.Buffer
+	db := memdb.NewMemDB()
+	baseStore := dbadapter.StoreConstructor(db, stypes.StoreOptions{})
+	iavlStore := iavl.StoreConstructor(db, stypes.StoreOptions{})
+	store := NewStore(nil, baseStore, iavlStore)
+
+	m := NewMachineWithOptions(MachineOptions{
+		Output: &buf,
+		Store:  store,
+	})
+
+	program := `package p
+                func main() {
+                    for i := 0; i < 1000; i++ {
+                        println("abcdeffffffffffffffff1222 11111   11111")
+                    }
+                }`
+	m.RunMemPackage(&gnovm.MemPackage{
+		Name: "p",
+		Path: "p",
+		Files: []*gnovm.MemFile{
+			{Name: "a.gno", Body: program},
+		},
+	}, false)
+
+	b.ReportAllocs()
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		buf.Reset()
+		m.RunStatement(S(Call(Nx("main"))))
+		pSink = buf.String()
+	}
+
+	if pSink == nil {
+		b.Fatal("Benchmark did not run!")
+	}
+}
+
+func TestGnoPrintAndPrintln(t *testing.T) {
+	tests := []struct {
+		name    string
+		srcArgs string
+		want    string
+	}{
+		{
+			"print with no args",
+			"print()",
+			"",
+		},
+		{
+			"print with 1 arg",
+			`print("1")`,
+			"1",
+		},
+		{
+			"print with 2 args",
+			`print("1", 2)`,
+			"1 2",
+		},
+		{
+			"print with 3 args",
+			`print("1", 2, "*")`,
+			"1 2 *",
+		},
+		{
+			"print with own spaces",
+			`print("1 ", 2, "*")`,
+			"1  2 *",
+		},
+		{
+			"println with no args",
+			"println()",
+			"",
+		},
+		{
+			"print with 1 arg",
+			`println("1")`,
+			"1\n",
+		},
+		{
+			"println with 2 args",
+			`println("1", 2)`,
+			"1 2\n",
+		},
+		{
+			"println with 3 args",
+			`println("1", 2, "*")`,
+			"1 2 *\n",
+		},
+		{
+			"println with own spaces",
+			`println("1 ", 2, "*")`,
+			"1  2 *\n",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var buf bytes.Buffer
+			db := memdb.NewMemDB()
+			baseStore := dbadapter.StoreConstructor(db, stypes.StoreOptions{})
+			iavlStore := iavl.StoreConstructor(db, stypes.StoreOptions{})
+			store := NewStore(nil, baseStore, iavlStore)
+
+			m := NewMachineWithOptions(MachineOptions{
+				Output: &buf,
+				Store:  store,
+			})
+
+			program := `package p
+                func main() {` + tt.srcArgs + "\n}"
+			m.RunMemPackage(&gnovm.MemPackage{
+				Name: "p",
+				Path: "p",
+				Files: []*gnovm.MemFile{
+					{Name: "a.gno", Body: program},
+				},
+			}, false)
+
+			buf.Reset()
+			m.RunStatement(S(Call(Nx("main"))))
+			got := buf.String()
+			if diff := cmp.Diff(got, tt.want); diff != "" {
+				t.Fatalf("Mismatched output: got - want +\n%s", diff)
+			}
+		})
+	}
+}

gnovm/pkg/gnolang/uverse.go

@@ -2,6 +2,7 @@ package gnolang
 
 import (
 	"fmt"
+	"io"
 	"strings"
 
 	bm "github.com/gnolang/gno/gnovm/pkg/benchops"
@@ -718,16 +719,32 @@ func makeUverseNode() {
 			arg0 := m.LastBlock().GetParams1()
 			xv := arg0
 			xvl := xv.TV.GetLength()
-			ss := make([]string, xvl)
-			for i := 0; i < xvl; i++ {
-				ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
-				ss[i] = ev.Sprint(m)
+			if xvl == 0 {
+				// Mimick Go in which invoking print() does nothing.
+				return
 			}
-			rs := strings.Join(ss, " ")
-			if debug {
+
+			switch debug {
+			case true:
+				ss := make([]string, xvl)
+				for i := 0; i < xvl; i++ {
+					ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
+					ss[i] = ev.Sprint(m)
+				}
+				rs := strings.Join(ss, " ")
 				print(rs)
+				io.WriteString(m.Output, rs)
+
+			default:
+				nMax := xvl - 1
+				for i := 0; i < xvl; i++ {
+					ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
+					io.WriteString(m.Output, ev.Sprint(m))
+					if i < nMax { // Not the last item.
+						io.WriteString(m.Output, " ")
+					}
+				}
 			}
-			m.Output.Write([]byte(rs))
 		},
 	)
 	defNative("println",
@@ -739,16 +756,33 @@ func makeUverseNode() {
 			arg0 := m.LastBlock().GetParams1()
 			xv := arg0
 			xvl := xv.TV.GetLength()
-			ss := make([]string, xvl)
-			for i := 0; i < xvl; i++ {
-				ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
-				ss[i] = ev.Sprint(m)
+			if xvl == 0 {
+				// Mimick Go in which invoking println() does nothing.
+				return
 			}
-			rs := strings.Join(ss, " ") + "\n"
-			if debug {
+
+			switch debug {
+			case true:
+				ss := make([]string, xvl)
+				for i := 0; i < xvl; i++ {
+					ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
+					ss[i] = ev.Sprint(m)
+				}
+				rs := strings.Join(ss, " ") + "\n"
 				println("DEBUG/stdout: " + rs)
+				io.WriteString(m.Output, rs)
+
+			default:
+				nMax := xvl - 1
+				for i := 0; i < xvl; i++ {
+					ev := xv.TV.GetPointerAtIndexInt(m.Store, i).Deref()
+					io.WriteString(m.Output, ev.Sprint(m))
+					if i < nMax { // Not the last item.
+						io.WriteString(m.Output, " ")
+					}
+				}
+				io.WriteString(m.Output, "\n")
 			}
-			m.Output.Write([]byte(rs))
 		},
 	)
 	defNative("recover",