Slow performance of html/template in Go lang, any workaround?

You are working with arrays and structs, both which are non-pointer types, nor are they descriptors (like slices or maps or channels). So passing them always creates a copy of the value, assigning an array value to a variable copies all the elements. This is slow and gives a huge amount of work to the GC.

Also you are utilizing only 1 CPU core. To utilize more, add this to your main() function:

func main() {
    runtime.GOMAXPROCS(runtime.NumCPU())
    http.HandleFunc("/", handler)
    log.Fatal(http.ListenAndServe(":8888", nil))
}

Edit: This was only the case prior to Go 1.5. Since Go 1.5 runtime.NumCPU() is the default.

Your code

var Posts [100]Post

An array with space for 100 Posts is allocated.

Posts[i] = Post{i, "Sample Title", "Lorem Ipsum Dolor Sit Amet"}

You create a Post value with a composite literal, then this value is copied into the ith element in the array. (redundant)

var p Page

This creates a variable of type Page. It is a struct, so its memory is allocated which also contains a field Posts [100]Post so another array of 100 elements is allocated.

p.Posts = Posts

This copies 100 elements (a hundred structs)!

tmpl.ExecuteTemplate(w, "index.html", p)

This creates a copy of p (which is of type Page), so another array of 100 posts is created and elements from p are copied, then it is passed to ExecuteTemplate().

And since Page.Posts is an array, most likely when it is processed (iterated over in the template engine), a copy will be made from each element (haven't checked - not verified).

Proposal for a more efficient code

Some things to speed up your code:

func handler(w http.ResponseWriter, r *http.Request) {
    type Post struct {
        Id int
        Title, Content string
    }

    Posts := make([]*Post, 100) // A slice of pointers

    // Fill posts
    for i := range Posts {
        // Initialize pointers: just copies the address of the created struct value
        Posts[i]= &Post{i, "Sample Title", "Lorem Ipsum Dolor Sit Amet"}
    }

    type Page struct {
        Title, Subtitle string
        Posts []*Post // "Just" a slice type (it's a descriptor)
    }

    // Create a page, only the Posts slice descriptor is copied
    p := Page{"Index Page of My Super Blog", "A blog about everything", Posts}

    tmpl := templates["index.html"]

    // Only pass the address of p
    // Although since Page.Posts is now just a slice, passing by value would also be OK 
    tmpl.ExecuteTemplate(w, "index.html", &p)
}

Please test this code and report back your results.


There are two main reasons why the equivalent application using html/template is slower than PHP variant.

First of all html/template provides more functionality than the PHP. The main difference is that html/template will automatically escape variables using correct escaping rules (HTML, JS, CSS, etc) depending on their location in the resulting HTML output (which I think is quite cool!).

Secondly html/template rendering code heavily uses reflection and methods with variable number of arguments and they are just not as fast as statically compiled code.

Under the hood the following template

{{ .Title }}
{{ .Subtitle }}

{{ range .Posts }}
    {{ .Title }}
    {{ .Content }}
{{ end }}

is converted to something like

{{ .Title | html_template_htmlescaper }}
{{ .Subtitle | html_template_htmlescaper }}

{{ range .Posts }}
    {{ .Title | html_template_htmlescaper }}
    {{ .Content | html_template_htmlescaper }}
{{ end }}

Calling html_template_htmlescaper using reflection in a loop kills performance.

Having said all that this micro-benchmark of html/template shouldn't be used to decide whether to use Go or not. Once you add code to work with the database to the request handler I suspect that template rendering time will hardly be noticeable.

Also I am pretty sure that over time both Go reflection and html/template package will become faster.

If in a real application you will find that html/template is a bottleneck it still possible to switch to text/template and supply it with already escaped data.

Tags:

Go

Go Html Template

Recent Posts