text/template: optimize Clone+Funcs+Execute sequence

[rsc]

In #31107 it came up that maybe most of the requested new functionality would be doable outside the package if it were possible to install new functions on a per-execution basis. One option is to add a new Execute that takes a second FuncMap, but I think we should consider not adding new API and instead make Clone+Funcs+Execute run faster.

It might be that all that's needed is making Clone make the actual template backing data copy-on-write. Then Clone is cheap. Then Funcs would copy only the map, or maybe even start a second map, also cheap. And Execute would be unchanged.

This issue is to think about whether this is possible to do without visible semantic changes, and if so, to do it.

/cc @bep @robpike @empijei

[empijei]

Thanks for opening this. It would indeed address my need to seamlessly provide a per-execution nonce on the framework side.

Both adding other functions and cloning would work.

[bep]

I assume you still would need to synchronize the clone? What is the cost compared to doing it the proper way (adding the funcs to the execution struct where they belong)?

[empijei]

What is the cost

This could be a lazy copy so potentially very little. It would just mark the template as being in use by more than one user and thus turning on a copy-on-write flag. I am similarly worried about this but Russ said this could be done with very little overhead.

doing it the proper way

Are you considering as an alternative to add a FuncMap to the Execute call? I would personally prefer it too but it would require an API change.

If your concern is about performance, would you be ok with expressing this semantic as Clone+Funcs+Execute (which has the perk of not changing the API) if it had a similar runtime cost?

[empijei]

@rsc I am still trying to wrap my head around this.

How could this be acceptably efficient to clone the templates every time we need to render them?

Most of our servers require to render the same template tens of times with different data and different nonces at the same time.

Can you please share a bit of technical details on what you had in mind to implement this so I can maybe start taking a look?

[zeripath]

One option is to add a new Execute that takes a second FuncMap, but I think we should consider not adding new API and instead make Clone+Funcs+Execute run faster.

I think I have to disagree here. The number of changes required to make Clone+Funcs+Execute faster will be immense.

Here's a simple patch that does ExecuteFuncMaps:

Patch

diff --git a/src/html/template/template.go b/src/html/template/template.go
index 30b64dff04..d473d54a7f 100644
--- a/src/html/template/template.go
+++ b/src/html/template/template.go
@@ -124,6 +124,20 @@ func (t *Template) Execute(wr io.Writer, data any) error {
 	return t.text.Execute(wr, data)
 }
 
+// ExecuteFuncMap applies a parsed template to the specified data object,
+// FuncMap overlay and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel, although if parallel
+// executions share a Writer the output may be interleaved.
+func (t *Template) ExecuteFuncMap(wr io.Writer, data any, funcs FuncMap) error {
+	if err := t.escape(); err != nil {
+		return err
+	}
+	return t.text.ExecuteFuncMap(wr, data, funcs)
+}
+
 // ExecuteTemplate applies the template associated with t that has the given
 // name to the specified data object and writes the output to wr.
 // If an error occurs executing the template or writing its output,
@@ -139,6 +153,21 @@ func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error {
 	return tmpl.text.Execute(wr, data)
 }
 
+// ExecuteTemplateFuncMap applies the template associated with t that has the given
+// name to the specified data object and FuncMap overlay writing the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel, although if parallel
+// executions share a Writer the output may be interleaved.
+func (t *Template) ExecuteTemplateFuncMap(wr io.Writer, name string, data any, funcs FuncMap) error {
+	tmpl, err := t.lookupAndEscapeTemplate(name)
+	if err != nil {
+		return err
+	}
+	return tmpl.text.ExecuteFuncMap(wr, data, funcs)
+}
+
 // lookupAndEscapeTemplate guarantees that the template with the given name
 // is escaped, or returns an error if it cannot be. It returns the named
 // template.
diff --git a/src/text/template/exec.go b/src/text/template/exec.go
index 37984cf91a..9a43edb08f 100644
--- a/src/text/template/exec.go
+++ b/src/text/template/exec.go
@@ -37,6 +37,7 @@ type state struct {
 	node  parse.Node // current node, for errors
 	vars  []variable // push-down stack of variable values.
 	depth int        // the height of the stack of executing templates.
+	funcs map[string]reflect.Value
 }
 
 // variable holds the dynamic value of a variable such as $, $x etc.
@@ -187,6 +188,21 @@ func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error {
 	return tmpl.Execute(wr, data)
 }
 
+// ExecuteTemplateFuncMap applies the template associated with t that has the given name
+// to the specified data object and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel, although if parallel
+// executions share a Writer the output may be interleaved.
+func (t *Template) ExecuteTemplateFuncMap(wr io.Writer, name string, data interface{}, funcs FuncMap) error {
+	tmpl := t.Lookup(name)
+	if tmpl == nil {
+		return fmt.Errorf("template: no template %q associated with template %q", name, t.name)
+	}
+	return tmpl.ExecuteFuncMap(wr, data, funcs)
+}
+
 // Execute applies a parsed template to the specified data object,
 // and writes the output to wr.
 // If an error occurs executing the template or writing its output,
@@ -198,10 +214,24 @@ func (t *Template) ExecuteTemplate(wr io.Writer, name string, data any) error {
 // If data is a reflect.Value, the template applies to the concrete
 // value that the reflect.Value holds, as in fmt.Print.
 func (t *Template) Execute(wr io.Writer, data any) error {
-	return t.execute(wr, data)
+	return t.execute(wr, data, nil)
 }
 
-func (t *Template) execute(wr io.Writer, data any) (err error) {
+// ExecuteFuncMap applies a parsed template to the specified data object,
+// FuncMap overlay and writes the output to wr.
+// If an error occurs executing the template or writing its output,
+// execution stops, but partial results may already have been written to
+// the output writer.
+// A template may be executed safely in parallel, although if parallel
+// executions share a Writer the output may be interleaved.
+//
+// If data is a reflect.Value, the template applies to the concrete
+// value that the reflect.Value holds, as in fmt.Print.
+func (t *Template) ExecuteFuncMap(wr io.Writer, data any, funcs FuncMap) error {
+	return t.execute(wr, data, funcs)
+}
+
+func (t *Template) execute(wr io.Writer, data any, funcs FuncMap) (err error) {
 	defer errRecover(&err)
 	value, ok := data.(reflect.Value)
 	if !ok {
@@ -211,7 +241,9 @@ func (t *Template) execute(wr io.Writer, data any) (err error) {
 		tmpl: t,
 		wr:   wr,
 		vars: []variable{{"$", value}},
+                funcs: map[string]reflect.Value{},
 	}
+	addValueFuncs(state.funcs, funcs)
 	if t.Tree == nil || t.Root == nil {
 		state.errorf("%q is an incomplete or empty template", t.Name())
 	}
@@ -436,6 +468,7 @@ func (s *state) walkTemplate(dot reflect.Value, t *parse.TemplateNode) {
 	newState.tmpl = tmpl
 	// No dynamic scoping: template invocations inherit no variables.
 	newState.vars = []variable{{"$", dot}}
+	newState.funcs = s.funcs
 	newState.walk(dot, tmpl.Root)
 }
 
@@ -594,9 +627,14 @@ func (s *state) evalFieldChain(dot, receiver reflect.Value, node parse.Node, ide
 func (s *state) evalFunction(dot reflect.Value, node *parse.IdentifierNode, cmd parse.Node, args []parse.Node, final reflect.Value) reflect.Value {
 	s.at(node)
 	name := node.Ident
-	function, isBuiltin, ok := findFunction(name, s.tmpl)
-	if !ok {
-		s.errorf("%q is not a defined function", name)
+	isBuiltin := false
+	function := s.funcs[name]
+	if !function.IsValid() {
+		ok := false
+		function, isBuiltin, ok = findFunction(name, s.tmpl)
+		if !ok {
+			s.errorf("%q is not a defined function", name)
+		}
 	}
 	return s.evalCall(dot, function, isBuiltin, cmd, name, args, final)
 }

As you can see this very small API change makes for a very clean and highly efficient way of providing execution FuncMap overlays.

[gopherbot]

Change https://go.dev/cl/423554 mentions this issue: text/template: add ExecuteFuncMap and ExecuteTemplateFuncMap

[wxiaoguang]

I think the PR text/template: add ExecuteFuncMap and ExecuteTemplateFuncMap #54432 is really helpful, and good enough.

How to push the proposal & progress? Thank you very much.