From 656d484d26bba7ce416aa925b0afc98d613c2dcd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Bj=C3=B8rn=20Erik=20Pedersen?=
 <bjorn.erik.pedersen@gmail.com>
Date: Thu, 25 Jun 2020 11:32:42 +0200
Subject: [PATCH] Consolidate most memory into a LRU cache

This commit also consolidates all (or the most important) memory caches in Hugo.

Fixes #7425
Fixes #7437
Fixes #7436
Updates #7544
---
 cache/memcache/memcache.go                    | 449 ++++++++++++++++++
 cache/memcache/memcache_test.go               | 205 ++++++++
 cache/namedmemcache/named_cache.go            |  79 ---
 cache/namedmemcache/named_cache_test.go       |  80 ----
 commands/hugo.go                              |  22 +-
 deps/deps.go                                  |  20 +-
 go.mod                                        |   3 +
 go.sum                                        |  15 +
 helpers/general.go                            |  18 +
 hugofs/fileinfo.go                            |   6 +
 hugofs/rootmapping_fs.go                      |   7 +-
 hugolib/content_map_page.go                   |   7 +
 hugolib/hugo_sites.go                         |   1 +
 hugolib/hugo_sites_build.go                   |   4 +
 hugolib/hugo_sites_build_test.go              |  11 +-
 hugolib/openapi_test.go                       |   1 +
 hugolib/pagebundler_test.go                   |   4 +-
 hugolib/paths/paths.go                        |   6 +-
 hugolib/resource_cache_test.go                | 173 +++++++
 hugolib/resource_chain_test.go                |   2 +-
 hugolib/testhelpers_test.go                   |  12 +-
 resources/image_cache.go                      | 163 +++----
 resources/image_test.go                       |   2 +-
 resources/post_publish.go                     |   5 +-
 resources/resource.go                         |   9 +-
 resources/resource_cache.go                   | 127 ++---
 .../resource_factories/bundler/bundler.go     |   3 +-
 resources/resource_factories/create/create.go |  11 +-
 resources/resource_metadata_test.go           |  12 +-
 resources/resource_spec.go                    |  50 +-
 resources/resource_test.go                    |  50 +-
 .../htesting/testhelpers.go                   |   4 +-
 resources/testhelpers_test.go                 |  27 +-
 resources/transform.go                        |  58 +--
 tpl/openapi/openapi3/openapi3.go              |  13 +-
 tpl/transform/init_test.go                    |   6 +-
 tpl/transform/transform.go                    |  15 +-
 tpl/transform/transform_test.go               |   3 +
 tpl/transform/unmarshal_test.go               |   2 +-
 39 files changed, 1157 insertions(+), 528 deletions(-)
 create mode 100644 cache/memcache/memcache.go
 create mode 100644 cache/memcache/memcache_test.go
 delete mode 100644 cache/namedmemcache/named_cache.go
 delete mode 100644 cache/namedmemcache/named_cache_test.go
 create mode 100644 hugolib/resource_cache_test.go

diff --git a/cache/memcache/memcache.go b/cache/memcache/memcache.go
new file mode 100644
index 00000000000..3f1a66387d8
--- /dev/null
+++ b/cache/memcache/memcache.go
@@ -0,0 +1,449 @@
+// Copyright 2020 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package memcache provides the core memory cache used in Hugo.
+package memcache
+
+import (
+	"path"
+	"runtime"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/gohugoio/hugo/helpers"
+	"github.com/pkg/errors"
+
+	"github.com/BurntSushi/locker"
+	"github.com/karlseguin/ccache/v2"
+	"github.com/pbnjay/memory"
+)
+
+const (
+	gigabyte = 1 << 30
+)
+
+const (
+	ClearNever ClearWhen = iota
+	ClearOnRebuild
+	ClearPerSite
+)
+
+var errInvalidKey = errors.New("invalid cache key")
+
+// New creates a new cache.
+func New(conf Config) *Cache {
+	if conf.TTL == 0 {
+		conf.TTL = time.Second * 33
+	}
+	if conf.CheckInterval == 0 {
+		conf.CheckInterval = time.Second * 2
+	}
+	if conf.MaxSize == 0 {
+		conf.MaxSize = 1000
+	}
+	if conf.ItemsToPrune == 0 {
+		conf.ItemsToPrune = 200
+	}
+
+	var m runtime.MemStats
+	runtime.ReadMemStats(&m)
+
+	var availableMemory uint64
+
+	// The total memory does not exclude memory used by other processes.
+	// For now, let's say that Hugo can use a fraction of it.
+	total := memory.TotalMemory()
+	if total != 0 {
+		availableMemory = total / 4
+	} else {
+		availableMemory = 2 * gigabyte
+	}
+
+	stats := &stats{
+		memstatsStart:   m,
+		maxSize:         conf.MaxSize,
+		availableMemory: availableMemory,
+	}
+
+	if stats.isLowOnMemory() {
+		conf.MaxSize = stats.newMaxSize()
+	}
+
+	c := &Cache{
+		conf:    conf,
+		cache:   ccache.Layered(ccache.Configure().MaxSize(conf.MaxSize).ItemsToPrune(conf.ItemsToPrune)),
+		getters: make(map[string]*getter),
+		ttl:     conf.TTL,
+		stats:   stats,
+		nlocker: locker.NewLocker(),
+	}
+
+	c.stop = c.start()
+
+	return c
+}
+
+// Cache configures a cache.
+type Cache struct {
+	mu      sync.Mutex
+	getters map[string]*getter
+
+	conf  Config
+	cache *ccache.LayeredCache
+
+	ttl     time.Duration
+	nlocker *locker.Locker
+
+	stats *stats
+	stop  func()
+}
+
+// Clear clears the cache state.
+// This method is not thread safe.
+func (c *Cache) Clear() {
+	c.nlocker = locker.NewLocker()
+	c.cache.Clear()
+}
+
+func (c *Cache) DeleteAll(primary string) bool {
+	return c.cache.DeleteAll(primary)
+}
+
+func (c *Cache) DeleteRelatedTo(filenames ...string) int {
+	var deleted int
+	for _, f := range filenames {
+		deleted += c.deleteRelatedTo(f)
+	}
+	return deleted
+}
+
+func (c *Cache) deleteRelatedTo(filename string) int {
+	var deleted int
+	path := CleanKey(filename)
+	prefix, suffix := splitBasePathAndExt(path)
+
+	for _, cc := range c.getters {
+		deleted += cc.deleteRelatedTo(prefix, suffix)
+	}
+
+	return deleted
+
+}
+
+func (c *Cache) GetDropped() int {
+	return c.cache.GetDropped()
+}
+
+func (c *Cache) GetOrCreatePartition(partition string, clearWhen ClearWhen) Getter {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if strings.Contains(strings.ToLower(partition), "todo") {
+		panic("TODO1")
+	}
+
+	g, found := c.getters[partition]
+	if found {
+		return g
+	}
+
+	var pe map[string]map[string]bool
+	if c.conf.Running {
+		pe = make(map[string]map[string]bool)
+	}
+
+	g = &getter{
+		partition:      partition,
+		c:              c,
+		prefixSuffixes: pe,
+		clearWhen:      clearWhen,
+	}
+
+	c.getters[partition] = g
+
+	return g
+}
+
+func (c *Cache) Stop() {
+	c.stop()
+	c.cache.Stop()
+}
+
+func (c *Cache) start() func() {
+	ticker := time.NewTicker(c.conf.CheckInterval)
+	quit := make(chan struct{})
+
+	checkAndAdjustMaxSize := func() {
+		var m runtime.MemStats
+		cacheDropped := c.GetDropped()
+		c.stats.decr(cacheDropped)
+
+		runtime.ReadMemStats(&m)
+		c.stats.memstatsCurrent = m
+		if c.stats.isLowOnMemory() {
+			c.cache.SetMaxSize(c.stats.newMaxSize())
+		}
+
+		//fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\nMemCacheDropped = %d\n\n", helpers.FormatByteCount(m.Alloc), helpers.FormatByteCount(m.TotalAlloc), helpers.FormatByteCount(m.Sys), m.NumGC, cacheDropped)
+
+	}
+	go func() {
+		for {
+			select {
+			case <-ticker.C:
+				checkAndAdjustMaxSize()
+			case <-quit:
+				ticker.Stop()
+				return
+			}
+		}
+	}()
+
+	return func() {
+		close(quit)
+	}
+}
+
+func (c *Cache) get(primary, secondary string) (interface{}, bool) {
+	v := c.cache.Get(primary, secondary)
+	if v == nil {
+		return nil, false
+	}
+	return v.Value(), true
+}
+
+// GetOrCreate tries to get the value with the given cache paths, if not found
+// create will be called and cached.
+// This method is thread safe.
+func (c *Cache) getOrCreate(primary, secondary string, create func() (interface{}, error)) (interface{}, error) {
+	if v := c.cache.Get(primary, secondary); v != nil {
+		entry := v.Value().(cacheEntry)
+		return entry.value, entry.err
+	}
+
+	// The provided create function may be a relatively time consuming operation,
+	// and there will in the commmon case be concurrent requests for the same key'd
+	// resource, so make sure we pause these until the result is ready.
+	path := primary + secondary
+	c.nlocker.Lock(path)
+	defer c.nlocker.Unlock(path)
+
+	// Try again.
+	if v := c.cache.Get(primary, secondary); v != nil {
+		entry := v.Value().(cacheEntry)
+		return entry.value, entry.err
+	}
+
+	// Create it and store it in cache.
+	value, err := create()
+
+	c.cache.Set(primary, secondary, cacheEntry{value: value, err: err, size: 1}, c.ttl)
+	c.stats.incr(1)
+
+	return value, err
+}
+
+type ClearWhen int
+
+type Config struct {
+	CheckInterval time.Duration
+	MaxSize       int64
+	ItemsToPrune  uint32
+	TTL           time.Duration
+	Running       bool
+}
+
+type Getter interface {
+	GetOrCreate(path string, create func() (interface{}, error)) (interface{}, error)
+	Get(path string) (interface{}, bool)
+	Clear()
+}
+
+type cacheEntry struct {
+	size  int64
+	value interface{}
+	err   error
+}
+
+func (c cacheEntry) Size() int64 {
+	return c.size
+}
+
+type getter struct {
+	c         *Cache
+	partition string
+
+	clearWhen ClearWhen
+
+	prefixExtensionsMu sync.RWMutex
+	prefixSuffixes     map[string]map[string]bool
+}
+
+func (g *getter) Clear() {
+	g.c.DeleteAll(g.partition)
+}
+
+func (g *getter) GetOrCreate(path string, create func() (interface{}, error)) (interface{}, error) {
+	return g.c.getOrCreate(g.partition, path, func() (interface{}, error) {
+		if !keyValid(path) {
+			return nil, errors.Errorf("key %q not valid", path)
+		}
+
+		if g.c.conf.Running {
+			prefix, suffix := splitBasePathAndExt(path)
+			g.trackPrefixSuffix(prefix, suffix)
+		}
+
+		return create()
+	})
+}
+
+func (g *getter) Get(path string) (interface{}, bool) {
+	return g.c.get(g.partition, path)
+}
+
+func (g *getter) deleteRelatedTo(prefix, suffix string) int {
+	g.prefixExtensionsMu.RLock()
+	defer g.prefixExtensionsMu.RUnlock()
+
+	prefixes := []string{prefix}
+
+	// Find all the suffixes cached with this prefix.
+	suffixes, found := g.prefixSuffixes[prefix]
+
+	if found {
+		for suffix, _ := range suffixes {
+			// Find all the prefixes with this suffix.
+			for k, v := range g.prefixSuffixes {
+				if v[suffix] {
+					prefixes = append(prefixes, k)
+				}
+			}
+
+		}
+	}
+
+	prefixes = helpers.UniqueStringsReuse(prefixes)
+
+	var deleted int
+	for _, prefix := range prefixes {
+		deleted += g.c.cache.DeletePrefix(g.partition, prefix)
+	}
+
+	return deleted
+
+}
+
+func (g *getter) trackPrefixSuffix(prefix, suffix string) {
+	g.prefixExtensionsMu.RLock()
+	pe, found1 := g.prefixSuffixes[prefix]
+	var found2 bool
+	if found1 {
+		found2 = pe[suffix]
+	}
+	g.prefixExtensionsMu.RUnlock()
+	if !found1 || !found2 {
+		g.prefixExtensionsMu.Lock()
+		if !found1 {
+			suffixes := make(map[string]bool)
+			suffixes[suffix] = true
+			g.prefixSuffixes[prefix] = suffixes
+		} else {
+			pe[suffix] = true
+		}
+
+		g.prefixExtensionsMu.Unlock()
+	}
+}
+
+type stats struct {
+	memstatsStart   runtime.MemStats
+	memstatsCurrent runtime.MemStats
+	maxSize         int64
+
+	// This is an estimated/best guess value. TODO1 env factor.
+	availableMemory uint64
+
+	numItems uint64
+}
+
+func (s *stats) isLowOnMemory() bool {
+	return s.memstatsCurrent.Alloc > s.availableMemory
+}
+
+func (s *stats) newMaxSize() int64 {
+	s.maxSize = s.maxSize / 2
+	if s.maxSize < 20 {
+		s.maxSize = 20
+	}
+	return s.maxSize
+}
+
+func (s *stats) decr(i int) {
+	atomic.AddUint64(&s.numItems, ^uint64(i-1))
+}
+
+func (s *stats) incr(i int) {
+	atomic.AddUint64(&s.numItems, uint64(i))
+}
+
+// This assumes a valid key path.
+func splitBasePathAndExt(path string) (string, string) {
+	dotIdx := strings.Index(path, ".")
+	ext := path[dotIdx+1:]
+	slashIdx := strings.Index(path, "/")
+
+	return path[:slashIdx], ext
+}
+
+// CleanKey turns s into a format suitable for a cache key for this package.
+// The key will be a Unix-styled path without any leading slash.
+// If the input string does not contain any slash, a root will be prepended.
+// If the input string does not contain any ".", a dummy file suffix will be appended.
+// These are to make sure that they can effectively partake in the "cache cleaning"
+// strategy used in server mode.
+func CleanKey(s string) string {
+	s = path.Clean(helpers.ToSlashTrimLeading(s))
+	if !strings.ContainsRune(s, '/') {
+		s = "CACHE_ROOT/" + s
+	}
+	if !strings.ContainsRune(s, '.') {
+		s += ".UNKNOWN"
+	}
+
+	return s
+}
+
+func keyValid(s string) bool {
+	if len(s) < 5 {
+		return false
+	}
+	if strings.ContainsRune(s, '\\') {
+		return false
+	}
+	if strings.HasPrefix(s, "/") {
+		return false
+	}
+	if !strings.ContainsRune(s, '/') {
+		return false
+	}
+
+	dotIdx := strings.Index(s, ".")
+	if dotIdx == -1 || dotIdx == len(s)-1 {
+		return false
+	}
+
+	return true
+}
diff --git a/cache/memcache/memcache_test.go b/cache/memcache/memcache_test.go
new file mode 100644
index 00000000000..90fdac00419
--- /dev/null
+++ b/cache/memcache/memcache_test.go
@@ -0,0 +1,205 @@
+// Copyright 2020 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package memcache
+
+import (
+	"fmt"
+	"path/filepath"
+	"sync"
+	"testing"
+	"time"
+
+	qt "github.com/frankban/quicktest"
+)
+
+func TestCache(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	cache := New(Config{})
+
+	counter := 0
+	create := func() (interface{}, error) {
+		counter++
+		return counter, nil
+	}
+
+	for i := 0; i < 5; i++ {
+		v1, err := cache.getOrCreate("a", "a1", create)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v1, qt.Equals, 1)
+		v2, err := cache.getOrCreate("a", "a2", create)
+		c.Assert(err, qt.IsNil)
+		c.Assert(v2, qt.Equals, 2)
+	}
+
+	cache.Clear()
+
+	v3, err := cache.getOrCreate("a", "a2", create)
+	c.Assert(err, qt.IsNil)
+	c.Assert(v3, qt.Equals, 3)
+}
+
+func TestCacheConcurrent(t *testing.T) {
+	t.Parallel()
+
+	c := qt.New(t)
+
+	var wg sync.WaitGroup
+
+	cache := New(Config{})
+
+	create := func(i int) func() (interface{}, error) {
+		return func() (interface{}, error) {
+			return i, nil
+		}
+	}
+
+	for i := 0; i < 10; i++ {
+		wg.Add(1)
+		go func() {
+			defer wg.Done()
+			for j := 0; j < 100; j++ {
+				id := fmt.Sprintf("id%d", j)
+				v, err := cache.getOrCreate("a", id, create(j))
+				c.Assert(err, qt.IsNil)
+				c.Assert(v, qt.Equals, j)
+			}
+		}()
+	}
+	wg.Wait()
+}
+
+func TestCacheMemStats(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	cache := New(Config{
+		ItemsToPrune:  10,
+		CheckInterval: 500 * time.Millisecond,
+	})
+
+	s := cache.stats
+
+	c.Assert(s.memstatsStart.Alloc > 0, qt.Equals, true)
+	c.Assert(s.memstatsCurrent.Alloc, qt.Equals, uint64(0))
+	c.Assert(s.availableMemory > 0, qt.Equals, true)
+	c.Assert(s.numItems, qt.Equals, uint64(0))
+
+	counter := 0
+	create := func() (interface{}, error) {
+		counter++
+		return counter, nil
+	}
+
+	for i := 1; i <= 20; i++ {
+		_, err := cache.getOrCreate("a", fmt.Sprintf("b%d", i), create)
+		c.Assert(err, qt.IsNil)
+	}
+
+	c.Assert(s.numItems, qt.Equals, uint64(20))
+	cache.cache.SetMaxSize(10)
+	time.Sleep(time.Millisecond * 600)
+	c.Assert(int(s.numItems), qt.Equals, 10)
+
+	c.Assert(s.memstatsCurrent.Alloc > 0, qt.Equals, true)
+}
+
+func TestDeleteRelated(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	create := func() (interface{}, error) {
+		return "value", nil
+	}
+
+	mustGetOrCreate := func(g Getter, path string) {
+		_, err := g.GetOrCreate(path, create)
+		c.Assert(err, qt.IsNil)
+	}
+
+	createAndFillCache := func() *Cache {
+		cache := New(Config{
+			Running: true,
+		})
+
+		p1 := cache.GetOrCreatePartition("p1", ClearNever)
+		p2 := cache.GetOrCreatePartition("p2", ClearNever)
+
+		mustGetOrCreate(p1, "a/b/c.json")
+		mustGetOrCreate(p1, "a/b/d.js")
+		mustGetOrCreate(p1, "b/c.txt")
+		mustGetOrCreate(p1, "c/d.doc")
+		mustGetOrCreate(p1, "ROOT/d.js")
+		mustGetOrCreate(p1, "ROOT/d.json")
+		mustGetOrCreate(p1, "ROOT/e.txt")
+		mustGetOrCreate(p2, "f/b/e.js")
+
+		return cache
+
+	}
+
+	cache := createAndFillCache()
+	c.Assert(cache.DeleteRelatedTo("c/c.doc"), qt.Equals, 1)
+
+	cache = createAndFillCache()
+	c.Assert(cache.DeleteRelatedTo("a/b/d.js"), qt.Equals, 5)
+
+	cache = createAndFillCache()
+	c.Assert(cache.DeleteRelatedTo("ROOT/foo.bar"), qt.Equals, 6)
+
+}
+
+func TestSplitBasePathAndExt(t *testing.T) {
+	t.Parallel()
+	c := qt.New(t)
+
+	tests := []struct {
+		path string
+		a    string
+		b    string
+	}{
+		{"a/b.json", "a", "json"},
+		{"a/b/c/d.json", "a", "json"},
+	}
+	for i, this := range tests {
+		msg := qt.Commentf("test %d", i)
+		a, b := splitBasePathAndExt(this.path)
+
+		c.Assert(a, qt.Equals, this.a, msg)
+		c.Assert(b, qt.Equals, this.b, msg)
+	}
+
+}
+
+func TestCleanKey(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(CleanKey(filepath.FromSlash("a/b/c.js")), qt.Equals, "a/b/c.js")
+	c.Assert(CleanKey("a//b////c.js"), qt.Equals, "a/b/c.js")
+	c.Assert(CleanKey("a.js"), qt.Equals, "CACHE_ROOT/a.js")
+	c.Assert(CleanKey("b/a"), qt.Equals, "b/a.UNKNOWN")
+
+}
+
+func TestKeyValid(t *testing.T) {
+	c := qt.New(t)
+
+	c.Assert(keyValid("a/b.j"), qt.Equals, true)
+	c.Assert(keyValid("a/b."), qt.Equals, false)
+	c.Assert(keyValid("a/b"), qt.Equals, false)
+	c.Assert(keyValid("/a/b.txt"), qt.Equals, false)
+	c.Assert(keyValid("a\\b.js"), qt.Equals, false)
+
+}
diff --git a/cache/namedmemcache/named_cache.go b/cache/namedmemcache/named_cache.go
deleted file mode 100644
index d8c229a013b..00000000000
--- a/cache/namedmemcache/named_cache.go
+++ /dev/null
@@ -1,79 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// Package namedmemcache provides a memory cache with a named lock. This is suitable
-// for situations where creating the cached resource can be time consuming or otherwise
-// resource hungry, or in situations where a "once only per key" is a requirement.
-package namedmemcache
-
-import (
-	"sync"
-
-	"github.com/BurntSushi/locker"
-)
-
-// Cache holds the cached values.
-type Cache struct {
-	nlocker *locker.Locker
-	cache   map[string]cacheEntry
-	mu      sync.RWMutex
-}
-
-type cacheEntry struct {
-	value interface{}
-	err   error
-}
-
-// New creates a new cache.
-func New() *Cache {
-	return &Cache{
-		nlocker: locker.NewLocker(),
-		cache:   make(map[string]cacheEntry),
-	}
-}
-
-// Clear clears the cache state.
-func (c *Cache) Clear() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-
-	c.cache = make(map[string]cacheEntry)
-	c.nlocker = locker.NewLocker()
-
-}
-
-// GetOrCreate tries to get the value with the given cache key, if not found
-// create will be called and cached.
-// This method is thread safe. It also guarantees that the create func for a given
-// key is invoced only once for this cache.
-func (c *Cache) GetOrCreate(key string, create func() (interface{}, error)) (interface{}, error) {
-	c.mu.RLock()
-	entry, found := c.cache[key]
-	c.mu.RUnlock()
-
-	if found {
-		return entry.value, entry.err
-	}
-
-	c.nlocker.Lock(key)
-	defer c.nlocker.Unlock(key)
-
-	// Create it.
-	value, err := create()
-
-	c.mu.Lock()
-	c.cache[key] = cacheEntry{value: value, err: err}
-	c.mu.Unlock()
-
-	return value, err
-}
diff --git a/cache/namedmemcache/named_cache_test.go b/cache/namedmemcache/named_cache_test.go
deleted file mode 100644
index 9feddb11f2a..00000000000
--- a/cache/namedmemcache/named_cache_test.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Copyright 2018 The Hugo Authors. All rights reserved.
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package namedmemcache
-
-import (
-	"fmt"
-	"sync"
-	"testing"
-
-	qt "github.com/frankban/quicktest"
-)
-
-func TestNamedCache(t *testing.T) {
-	t.Parallel()
-	c := qt.New(t)
-
-	cache := New()
-
-	counter := 0
-	create := func() (interface{}, error) {
-		counter++
-		return counter, nil
-	}
-
-	for i := 0; i < 5; i++ {
-		v1, err := cache.GetOrCreate("a1", create)
-		c.Assert(err, qt.IsNil)
-		c.Assert(v1, qt.Equals, 1)
-		v2, err := cache.GetOrCreate("a2", create)
-		c.Assert(err, qt.IsNil)
-		c.Assert(v2, qt.Equals, 2)
-	}
-
-	cache.Clear()
-
-	v3, err := cache.GetOrCreate("a2", create)
-	c.Assert(err, qt.IsNil)
-	c.Assert(v3, qt.Equals, 3)
-}
-
-func TestNamedCacheConcurrent(t *testing.T) {
-	t.Parallel()
-
-	c := qt.New(t)
-
-	var wg sync.WaitGroup
-
-	cache := New()
-
-	create := func(i int) func() (interface{}, error) {
-		return func() (interface{}, error) {
-			return i, nil
-		}
-	}
-
-	for i := 0; i < 10; i++ {
-		wg.Add(1)
-		go func() {
-			defer wg.Done()
-			for j := 0; j < 100; j++ {
-				id := fmt.Sprintf("id%d", j)
-				v, err := cache.GetOrCreate(id, create(j))
-				c.Assert(err, qt.IsNil)
-				c.Assert(v, qt.Equals, j)
-			}
-		}()
-	}
-	wg.Wait()
-}
diff --git a/commands/hugo.go b/commands/hugo.go
index 5442c32d708..de311aaa646 100644
--- a/commands/hugo.go
+++ b/commands/hugo.go
@@ -433,8 +433,14 @@ func (c *commandeer) initMemTicker() func() {
 	quit := make(chan struct{})
 	printMem := func() {
 		var m runtime.MemStats
+		var cacheDropped int
+		h := c.hugo()
+		if h != nil && h.MemCache != nil {
+			cacheDropped = h.MemCache.GetDropped()
+		}
+
 		runtime.ReadMemStats(&m)
-		fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\n\n", formatByteCount(m.Alloc), formatByteCount(m.TotalAlloc), formatByteCount(m.Sys), m.NumGC)
+		fmt.Printf("\n\nAlloc = %v\nTotalAlloc = %v\nSys = %v\nNumGC = %v\nMemCacheDropped = %d\n\n", helpers.FormatByteCount(m.Alloc), helpers.FormatByteCount(m.TotalAlloc), helpers.FormatByteCount(m.Sys), m.NumGC, cacheDropped)
 
 	}
 
@@ -1215,17 +1221,3 @@ func pickOneWriteOrCreatePath(events []fsnotify.Event) string {
 
 	return name
 }
-
-func formatByteCount(b uint64) string {
-	const unit = 1000
-	if b < unit {
-		return fmt.Sprintf("%d B", b)
-	}
-	div, exp := int64(unit), 0
-	for n := b / unit; n >= unit; n /= unit {
-		div *= unit
-		exp++
-	}
-	return fmt.Sprintf("%.1f %cB",
-		float64(b)/float64(div), "kMGTPE"[exp])
-}
diff --git a/deps/deps.go b/deps/deps.go
index 82a16ba5947..c7ef99b65f5 100644
--- a/deps/deps.go
+++ b/deps/deps.go
@@ -5,6 +5,8 @@ import (
 	"sync/atomic"
 	"time"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"github.com/pkg/errors"
 
 	"github.com/gohugoio/hugo/cache/filecache"
@@ -62,9 +64,12 @@ type Deps struct {
 	// The configuration to use
 	Cfg config.Provider `json:"-"`
 
-	// The file cache to use.
+	// The file caches to use.
 	FileCaches filecache.Caches
 
+	// The memory cache to use.
+	MemCache *memcache.Cache
+
 	// The translation func to use
 	Translate func(translationID string, args ...interface{}) string `json:"-"`
 
@@ -158,6 +163,13 @@ type ResourceProvider interface {
 	Clone(deps *Deps) error
 }
 
+// Stop stops all running caches etc.
+func (d *Deps) Stop() {
+	if d.MemCache != nil {
+		d.MemCache.Stop()
+	}
+}
+
 func (d *Deps) Tmpl() tpl.TemplateHandler {
 	return d.tmpl
 }
@@ -236,11 +248,12 @@ func New(cfg DepsCfg) (*Deps, error) {
 	if err != nil {
 		return nil, errors.WithMessage(err, "failed to create file caches from configuration")
 	}
+	memCache := memcache.New(memcache.Config{Running: cfg.Running})
 
 	errorHandler := &globalErrHandler{}
 	buildState := &BuildState{}
 
-	resourceSpec, err := resources.NewSpec(ps, fileCaches, buildState, logger, errorHandler, cfg.OutputFormats, cfg.MediaTypes)
+	resourceSpec, err := resources.NewSpec(ps, fileCaches, memCache, buildState, logger, errorHandler, cfg.OutputFormats, cfg.MediaTypes)
 	if err != nil {
 		return nil, err
 	}
@@ -277,6 +290,7 @@ func New(cfg DepsCfg) (*Deps, error) {
 		Language:                cfg.Language,
 		Site:                    cfg.Site,
 		FileCaches:              fileCaches,
+		MemCache:                memCache,
 		BuildStartListeners:     &Listeners{},
 		BuildState:              buildState,
 		Timeout:                 time.Duration(timeoutms) * time.Millisecond,
@@ -311,7 +325,7 @@ func (d Deps) ForLanguage(cfg DepsCfg, onCreated func(d *Deps) error) (*Deps, er
 	// The resource cache is global so reuse.
 	// TODO(bep) clean up these inits.
 	resourceCache := d.ResourceSpec.ResourceCache
-	d.ResourceSpec, err = resources.NewSpec(d.PathSpec, d.ResourceSpec.FileCaches, d.BuildState, d.Log, d.globalErrHandler, cfg.OutputFormats, cfg.MediaTypes)
+	d.ResourceSpec, err = resources.NewSpec(d.PathSpec, d.ResourceSpec.FileCaches, d.MemCache, d.BuildState, d.Log, d.globalErrHandler, cfg.OutputFormats, cfg.MediaTypes)
 	if err != nil {
 		return nil, err
 	}
diff --git a/go.mod b/go.mod
index 161333daeca..fde75c9d888 100644
--- a/go.mod
+++ b/go.mod
@@ -26,6 +26,8 @@ require (
 	github.com/google/go-cmp v0.3.2-0.20191028172631-481baca67f93
 	github.com/gorilla/websocket v1.4.1
 	github.com/jdkato/prose v1.1.1
+	github.com/karlseguin/ccache v1.0.2-0.20200626122230-40275a30c888
+	github.com/karlseguin/ccache/v2 v2.0.7-0.20200812003947-223703f7f0b5
 	github.com/kr/pretty v0.2.0 // indirect
 	github.com/kyokomi/emoji v2.2.1+incompatible
 	github.com/magefile/mage v1.9.0
@@ -39,6 +41,7 @@ require (
 	github.com/nicksnyder/go-i18n v1.10.0
 	github.com/niklasfasching/go-org v1.3.1
 	github.com/olekukonko/tablewriter v0.0.4
+	github.com/pbnjay/memory v0.0.0-20190104145345-974d429e7ae4
 	github.com/pelletier/go-toml v1.6.0 // indirect
 	github.com/pkg/errors v0.9.1
 	github.com/rogpeppe/go-internal v1.5.1
diff --git a/go.sum b/go.sum
index e47c224795f..6306495a956 100644
--- a/go.sum
+++ b/go.sum
@@ -223,6 +223,18 @@ github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1
 github.com/jtolds/gls v4.20.0+incompatible h1:xdiiI2gbIgH/gLH7ADydsJ1uDOEzR8yvV7C0MuV77Wo=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/karlseguin/ccache v1.0.1 h1:0gpC6z1qtv0cKmsi5Su5tTB6bJ2vm9bfOLACpDEB/Ro=
+github.com/karlseguin/ccache v1.0.2-0.20200216035407-d9aec58960c7 h1:JLz65tG+cbiJ/Yj46FF3rmVmH61g6TI8YWq8p0AX5Zc=
+github.com/karlseguin/ccache v1.0.2-0.20200216035407-d9aec58960c7/go.mod h1:bm6z3svDxOYoWqVvk2JmnwOr6dtrTru4/MmlXksuQxk=
+github.com/karlseguin/ccache v1.0.2-0.20200626122230-40275a30c888 h1:Pgq9C5Cc/VUYV3Jm9JhzWNPzj5ghtCZ+0CgvtVRx4w4=
+github.com/karlseguin/ccache v1.0.2-0.20200626122230-40275a30c888/go.mod h1:bm6z3svDxOYoWqVvk2JmnwOr6dtrTru4/MmlXksuQxk=
+github.com/karlseguin/ccache v2.0.3+incompatible h1:j68C9tWOROiOLWTS/kCGg9IcJG+ACqn5+0+t8Oh83UU=
+github.com/karlseguin/ccache v2.0.3+incompatible/go.mod h1:CM9tNPzT6EdRh14+jiW8mEF9mkNZuuE51qmgGYUB93w=
+github.com/karlseguin/ccache/v2 v2.0.6 h1:jFCLz4bF4EPfuCcvESAgYNClkEb31LV3WzyOwLlFz7w=
+github.com/karlseguin/ccache/v2 v2.0.6/go.mod h1:2BDThcfQMf/c0jnZowt16eW405XIqZPavt+HoYEtcxQ=
+github.com/karlseguin/ccache/v2 v2.0.7-0.20200812003947-223703f7f0b5 h1:6eBqXgUzzakiY3AykWKzsqkf/qbaNJdOG5I31JxgiX0=
+github.com/karlseguin/ccache/v2 v2.0.7-0.20200812003947-223703f7f0b5/go.mod h1:2BDThcfQMf/c0jnZowt16eW405XIqZPavt+HoYEtcxQ=
+github.com/karlseguin/expect v1.0.2-0.20190806010014-778a5f0c6003/go.mod h1:zNBxMY8P21owkeogJELCLeHIt+voOSduHYTFUbwRAV8=
 github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
 github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
 github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
@@ -285,6 +297,8 @@ github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+W
 github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
 github.com/opentracing/opentracing-go v1.0.2/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
 github.com/openzipkin/zipkin-go v0.1.6/go.mod h1:QgAqvLzwWbR/WpD4A3cGpPtJrZXNIiJc5AZX7/PBEpw=
+github.com/pbnjay/memory v0.0.0-20190104145345-974d429e7ae4 h1:MfIUBZ1bz7TgvQLVa/yPJZOGeKEgs6eTKUjz3zB4B+U=
+github.com/pbnjay/memory v0.0.0-20190104145345-974d429e7ae4/go.mod h1:RMU2gJXhratVxBDTFeOdNhd540tG57lt9FIUV0YLvIQ=
 github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
 github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
 github.com/pelletier/go-toml v1.6.0 h1:aetoXYr0Tv7xRU/V4B4IZJ2QcbtMUFoNb3ORp7TzIK4=
@@ -388,6 +402,7 @@ github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGr
 github.com/ugorji/go/codec v0.0.0-20181204163529-d75b2dcb6bc8/go.mod h1:VFNgLljTbGfSG7qAOspJ7OScBnGdDN/yBr0sguwnwf0=
 github.com/valyala/bytebufferpool v1.0.0/go.mod h1:6bBcMArwyJ5K/AmCkWv1jt77kVWyCJ6HpOuEn7z0Csc=
 github.com/valyala/fasttemplate v1.0.1/go.mod h1:UQGH1tvbgY+Nz5t2n7tXsz52dQxojPUpymEIMZ47gx8=
+github.com/wsxiaoys/terminal v0.0.0-20160513160801-0940f3fc43a0/go.mod h1:IXCdmsXIht47RaVFLEdVnh1t+pgYtTAhQGj73kz+2DM=
 github.com/xdg/scram v0.0.0-20180814205039-7eeb5667e42c/go.mod h1:lB8K/P019DLNhemzwFU4jHLhdvlE6uDZjXFejJXr49I=
 github.com/xdg/stringprep v1.0.0/go.mod h1:Jhud4/sHMO4oL310DaZAKk9ZaJ08SJfe+sJh0HrGL1Y=
 github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
diff --git a/helpers/general.go b/helpers/general.go
index 80e303087a5..377cba65578 100644
--- a/helpers/general.go
+++ b/helpers/general.go
@@ -61,6 +61,24 @@ func FindAvailablePort() (*net.TCPAddr, error) {
 	return nil, err
 }
 
+// FormatByteCount pretty formats b.
+func FormatByteCount(bc uint64) string {
+	const (
+		Gigabyte = 1 << 30
+		Megabyte = 1 << 20
+		Kilobyte = 1 << 10
+	)
+	switch {
+	case bc > Gigabyte || -bc > Gigabyte:
+		return fmt.Sprintf("%.2f GB", float64(bc)/Gigabyte)
+	case bc > Megabyte || -bc > Megabyte:
+		return fmt.Sprintf("%.2f MB", float64(bc)/Megabyte)
+	case bc > Kilobyte || -bc > Kilobyte:
+		return fmt.Sprintf("%.2f KB", float64(bc)/Kilobyte)
+	}
+	return fmt.Sprintf("%d B", bc)
+}
+
 // InStringArray checks if a string is an element of a slice of strings
 // and returns a boolean value.
 func InStringArray(arr []string, el string) bool {
diff --git a/hugofs/fileinfo.go b/hugofs/fileinfo.go
index 79d89a88b56..937a159815e 100644
--- a/hugofs/fileinfo.go
+++ b/hugofs/fileinfo.go
@@ -40,6 +40,7 @@ const (
 	metaKeyBaseDir                    = "baseDir" // Abs base directory of source file.
 	metaKeyMountRoot                  = "mountRoot"
 	metaKeyModule                     = "module"
+	metaKeyComponent                  = "component"
 	metaKeyOriginalFilename           = "originalFilename"
 	metaKeyName                       = "name"
 	metaKeyPath                       = "path"
@@ -132,6 +133,11 @@ func (f FileMeta) MountRoot() string {
 	return f.stringV(metaKeyMountRoot)
 }
 
+// TODO1 check usage
+func (f FileMeta) Component() string {
+	return f.stringV(metaKeyComponent)
+}
+
 func (f FileMeta) Module() string {
 	return f.stringV(metaKeyModule)
 }
diff --git a/hugofs/rootmapping_fs.go b/hugofs/rootmapping_fs.go
index ea3ef003ecc..a031f1ec04d 100644
--- a/hugofs/rootmapping_fs.go
+++ b/hugofs/rootmapping_fs.go
@@ -41,8 +41,8 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) {
 	for _, rm := range rms {
 		(&rm).clean()
 
-		fromBase := files.ResolveComponentFolder(rm.From)
-		if fromBase == "" {
+		component := files.ResolveComponentFolder(rm.From)
+		if component == "" {
 			panic("unrecognised component folder in" + rm.From)
 		}
 
@@ -58,7 +58,7 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) {
 			return nil, err
 		}
 		// Extract "blog" from "content/blog"
-		rm.path = strings.TrimPrefix(strings.TrimPrefix(rm.From, fromBase), filepathSeparator)
+		rm.path = strings.TrimPrefix(strings.TrimPrefix(rm.From, component), filepathSeparator)
 		if rm.Meta == nil {
 			rm.Meta = make(FileMeta)
 		}
@@ -66,6 +66,7 @@ func NewRootMappingFs(fs afero.Fs, rms ...RootMapping) (*RootMappingFs, error) {
 		rm.Meta[metaKeyBaseDir] = rm.ToBasedir
 		rm.Meta[metaKeyMountRoot] = rm.path
 		rm.Meta[metaKeyModule] = rm.Module
+		rm.Meta[metaKeyComponent] = component
 
 		meta := copyFileMeta(rm.Meta)
 
diff --git a/hugolib/content_map_page.go b/hugolib/content_map_page.go
index b32f808c971..a7af2a290c0 100644
--- a/hugolib/content_map_page.go
+++ b/hugolib/content_map_page.go
@@ -251,6 +251,13 @@ func (m *pageMap) newResource(fim hugofs.FileMetaInfo, owner *pageState) (resour
 	}
 
 	target := strings.TrimPrefix(meta.Path(), owner.File().Dir())
+	tbase := meta.TranslationBaseNameWithExt()
+	if tbase != "" {
+		dir, base := filepath.Split(target)
+		if base != tbase {
+			target = filepath.Join(dir, tbase)
+		}
+	}
 
 	return owner.s.ResourceSpec.New(
 		resources.ResourceSourceDescriptor{
diff --git a/hugolib/hugo_sites.go b/hugolib/hugo_sites.go
index d1e3a146d6d..44ff9791837 100644
--- a/hugolib/hugo_sites.go
+++ b/hugolib/hugo_sites.go
@@ -563,6 +563,7 @@ func (h *HugoSites) reset(config *BuildCfg) {
 	}
 
 	h.init.Reset()
+	h.MemCache.Clear()
 }
 
 // resetLogs resets the log counters etc. Used to do a new build on the same sites.
diff --git a/hugolib/hugo_sites_build.go b/hugolib/hugo_sites_build.go
index 67ee10e0978..b1d94c4eed4 100644
--- a/hugolib/hugo_sites_build.go
+++ b/hugolib/hugo_sites_build.go
@@ -51,6 +51,10 @@ func (h *HugoSites) Build(config BuildCfg, events ...fsnotify.Event) error {
 		// Make sure we don't trigger rebuilds in parallel.
 		h.runningMu.Lock()
 		defer h.runningMu.Unlock()
+	} else {
+		defer func() {
+			h.Stop()
+		}()
 	}
 
 	ctx, task := trace.NewTask(context.Background(), "Build")
diff --git a/hugolib/hugo_sites_build_test.go b/hugolib/hugo_sites_build_test.go
index 8d0872bd5e0..c5c40c29b1d 100644
--- a/hugolib/hugo_sites_build_test.go
+++ b/hugolib/hugo_sites_build_test.go
@@ -417,15 +417,18 @@ func doTestMultiSitesBuild(t *testing.T, configTemplate, configSuffix string) {
 
 func TestMultiSitesRebuild(t *testing.T) {
 	// t.Parallel() not supported, see https://github.com/fortytw2/leaktest/issues/4
-	// This leaktest seems to be a little bit shaky on Travis.
-	if !isCI() {
-		defer leaktest.CheckTimeout(t, 10*time.Second)()
-	}
 
 	c := qt.New(t)
 
 	b := newMultiSiteTestDefaultBuilder(t).Running().CreateSites().Build(BuildCfg{})
 
+	defer b.H.Stop()
+
+	// This leaktest seems to be a little bit shaky on Travis.
+	if !isCI() {
+		defer leaktest.CheckTimeout(t, 10*time.Second)()
+	}
+
 	sites := b.H.Sites
 	fs := b.Fs
 
diff --git a/hugolib/openapi_test.go b/hugolib/openapi_test.go
index 82f080311af..7605c104aa6 100644
--- a/hugolib/openapi_test.go
+++ b/hugolib/openapi_test.go
@@ -18,6 +18,7 @@ import (
 	"testing"
 )
 
+// TODO1 cache key when targetPath is set?
 func TestOpenAPI3(t *testing.T) {
 	const openapi3Yaml = `openapi: 3.0.0
 info:
diff --git a/hugolib/pagebundler_test.go b/hugolib/pagebundler_test.go
index fa420a025aa..476d09209f2 100644
--- a/hugolib/pagebundler_test.go
+++ b/hugolib/pagebundler_test.go
@@ -347,7 +347,7 @@ func TestPageBundlerSiteMultilingual(t *testing.T) {
 				b.AssertFileContent("public/en/bc/data1.json", "data1")
 				b.AssertFileContent("public/en/bc/data2.json", "data2")
 				b.AssertFileContent("public/en/bc/logo-bc.png", "logo")
-				b.AssertFileContent("public/nn/bc/data1.nn.json", "data1.nn")
+				b.AssertFileContent("public/nn/bc/data1.json", "data1.nn")
 				b.AssertFileContent("public/nn/bc/data2.json", "data2")
 				b.AssertFileContent("public/nn/bc/logo-bc.png", "logo")
 
@@ -1320,7 +1320,7 @@ bundle min min key: {{ $jsonMinMin.Key }}
 
 			b.AssertFileContent(index,
 				fmt.Sprintf("bundle min min min: /bundle%d/data.min.min.min.json", i),
-				fmt.Sprintf("bundle min min key: /bundle%d/data.min.min.json", i),
+				fmt.Sprintf("bundle min min key: bundle%d/data.min.min.json", i),
 			)
 			b.Assert(b.CheckExists(fmt.Sprintf("public/bundle%d/data.min.min.min.json", i)), qt.Equals, true)
 			b.Assert(b.CheckExists(fmt.Sprintf("public/bundle%d/data.min.json", i)), qt.Equals, false)
diff --git a/hugolib/paths/paths.go b/hugolib/paths/paths.go
index 97d4f17bab7..066c788fd16 100644
--- a/hugolib/paths/paths.go
+++ b/hugolib/paths/paths.go
@@ -53,6 +53,8 @@ type Paths struct {
 
 	PublishDir string
 
+	IsMultiHost bool
+
 	// When in multihost mode, this returns a list of base paths below PublishDir
 	// for each language.
 	MultihostTargetBasePaths []string
@@ -142,7 +144,8 @@ func New(fs *hugofs.Fs, cfg config.Provider) (*Paths, error) {
 	}
 
 	var multihostTargetBasePaths []string
-	if languages.IsMultihost() {
+	isMultiHost := languages.IsMultihost()
+	if isMultiHost {
 		for _, l := range languages {
 			multihostTargetBasePaths = append(multihostTargetBasePaths, l.Lang)
 		}
@@ -171,6 +174,7 @@ func New(fs *hugofs.Fs, cfg config.Provider) (*Paths, error) {
 		Language:                 language,
 		Languages:                languages,
 		LanguagesDefaultFirst:    languagesDefaultFirst,
+		IsMultiHost:              isMultiHost,
 		MultihostTargetBasePaths: multihostTargetBasePaths,
 
 		PaginatePath: cfg.GetString("paginatePath"),
diff --git a/hugolib/resource_cache_test.go b/hugolib/resource_cache_test.go
new file mode 100644
index 00000000000..d177b6164f0
--- /dev/null
+++ b/hugolib/resource_cache_test.go
@@ -0,0 +1,173 @@
+// Copyright 2020 The Hugo Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package hugolib
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+)
+
+// TODO1 write issue: resources with language indicator in filename
+// TODO1 write issue:
+func TestResourceCacheMultihost(t *testing.T) {
+	toLang := func(format, lang string) string {
+		return fmt.Sprintf(format, lang)
+	}
+
+	addContent := func(b *sitesBuilder, contentPath func(path, lang string) string) {
+		b.WithNoContentAdded()
+		for _, lang := range []string{"en", "fr"} {
+			b.WithSourceFile(
+				contentPath("b1/index.md", lang), toLang("---\ntitle: Bundle 1 %s\n---", lang),
+				contentPath("b1/styles/style11.css", lang), toLang(".%s1: { color: blue };", lang),
+				contentPath("b1/styles/style12.css", lang), toLang(".%s2: { color: red };", lang),
+			)
+			b.WithSourceFile(
+				contentPath("b2/index.md", lang), toLang("---\ntitle: Bundle 2 %s\n---", lang),
+				contentPath("b2/styles/style21.css", lang), toLang(".%s21: { color: green };", lang),
+				contentPath("b2/styles/style22.css", lang), toLang(".%s22: { color: orange };", lang),
+			)
+		}
+	}
+
+	addTemplates := func(b *sitesBuilder) {
+		b.WithTemplates("_default/single.html", `
+{{ template "print-page" (dict "page" . "title" "Self") }}
+{{ $other := site.Sites.First.GetPage "b1" }}
+{{ template "print-page" (dict "page" $other "title" "Other") }}
+	
+
+{{ define "print-page" }}
+{{ $p := .page }}
+{{ $title := .title }}
+{{ $styles := $p.Resources.Match "**/style1*.css" }}
+{{ if $styles }}
+{{ $mystyles := $styles | resources.Concat "mystyles.css" }}
+{{ $title }} Mystyles CSS: {{ $mystyles.RelPermalink }}|{{ $mystyles.Content }}
+{{ end }}
+{{ $title }} Bundle: {{ $p.Permalink }}
+{{ $style := $p.Resources.GetMatch "**.css" }}
+{{ $title }} CSS: {{ $style.RelPermalink }}|{{ $style.Content }}
+{{ $minified := $style | minify }}
+{{ $title }} Minified CSS: {{ $minified.RelPermalink }}|{{ $minified.Content }}
+{{ end }}
+
+`)
+	}
+
+	assertContent := func(b *sitesBuilder) {
+
+		otherAssert := `Other Mystyles CSS: /mystyles.css|.en1: { color: blue };.en2: { color: red };
+Other Bundle: https://example.com/b1/
+Other CSS: /b1/styles/style11.css|.en1: { color: blue };
+Other Minified CSS: /b1/styles/style11.min.css|.en1:{color:blue}
+`
+
+		b.AssertFileContent("public/fr/b1/index.html", `
+Self Mystyles CSS: /mystyles.css|.en1: { color: blue };.en2: { color: red };
+Self Bundle: https://example.fr/b1/
+Self CSS: /b1/styles/style11.css|.fr1: { color: blue };
+Self Minified CSS: /b1/styles/style11.min.css|.fr1:{color:blue}
+
+`,
+			otherAssert)
+		b.AssertFileContent("public/en/b1/index.html", `
+Self Mystyles CSS: /mystyles.css|.en1: { color: blue };.en2: { color: red };
+Self Bundle: https://example.com/b1/
+Self CSS: /b1/styles/style11.css|.en1: { color: blue };
+Self Minified CSS: /b1/styles/style11.min.css|.en1:{color:blue}
+`, otherAssert)
+
+		b.AssertFileContent("public/fr/b2/index.html", `
+Self Bundle: https://example.fr/b2/
+Self CSS: /b2/styles/style21.css|.fr21: { color: green };
+Self Minified CSS: /b2/styles/style21.min.css|.fr21:{color:green}
+`, otherAssert)
+
+		b.AssertFileContent("public/en/b2/index.html", `
+Self Bundle: https://example.com/b2/ 
+Self CSS: /b2/styles/style21.css|.en21: { color: green };
+Self Minified CSS: /b2/styles/style21.min.css|.en21:{color:green}
+`, otherAssert)
+
+	}
+
+	t.Run("Default content", func(t *testing.T) {
+
+		var configTemplate = `
+paginate = 1
+defaultContentLanguage = "fr"
+defaultContentLanguageInSubdir = false
+contentDir = "content"
+
+[Languages]
+[Languages.en]
+baseURL = "https://example.com/"
+weight = 10
+languageName = "English"
+
+[Languages.fr]
+baseURL = "https://example.fr"
+weight = 20
+languageName = "Français"
+
+`
+
+		b := newTestSitesBuilder(t).WithConfigFile("toml", configTemplate)
+		fmt.Println(b.workingDir)
+		addContent(b, func(path, lang string) string {
+			path = strings.Replace(path, ".", "."+lang+".", 1)
+			path = "content/" + path
+			return path
+		})
+		addTemplates(b)
+		b.Build(BuildCfg{})
+		assertContent(b)
+
+	})
+
+	t.Run("Content dir per language", func(t *testing.T) {
+
+		var configTemplate = `
+paginate = 1
+defaultContentLanguage = "fr"
+defaultContentLanguageInSubdir = false
+
+[Languages]
+[Languages.en]
+contentDir = "content_en"
+baseURL = "https://example.com/"
+weight = 10
+languageName = "English"
+
+[Languages.fr]
+contentDir = "content_fr"
+baseURL = "https://example.fr"
+weight = 20
+languageName = "Français"
+
+`
+
+		b := newTestSitesBuilder(t).WithConfigFile("toml", configTemplate)
+		addContent(b, func(path, lang string) string {
+			return "content_" + lang + "/" + path
+		})
+		addTemplates(b)
+		b.Build(BuildCfg{})
+		assertContent(b)
+
+	})
+
+}
diff --git a/hugolib/resource_chain_test.go b/hugolib/resource_chain_test.go
index c687ca3421b..e208d4d2ed2 100644
--- a/hugolib/resource_chain_test.go
+++ b/hugolib/resource_chain_test.go
@@ -350,7 +350,7 @@ Edited content.
 `)
 
 		b.Assert(b.Fs.Destination.Remove("public"), qt.IsNil)
-		b.H.ResourceSpec.ClearCaches()
+		b.H.MemCache.Clear()
 
 	}
 }
diff --git a/hugolib/testhelpers_test.go b/hugolib/testhelpers_test.go
index 2af4691d173..2000aa4d6b2 100644
--- a/hugolib/testhelpers_test.go
+++ b/hugolib/testhelpers_test.go
@@ -92,7 +92,8 @@ type sitesBuilder struct {
 	// Consider this in relation to using the BaseFs.PublishFs to all publishing.
 	workingDir string
 
-	addNothing bool
+	addNothing   bool
+	addNoContent bool
 	// Base data/content
 	contentFilePairs  []filenameContent
 	templateFilePairs []filenameContent
@@ -154,6 +155,11 @@ func (s *sitesBuilder) WithNothingAdded() *sitesBuilder {
 	return s
 }
 
+func (s *sitesBuilder) WithNoContentAdded() *sitesBuilder {
+	s.addNoContent = true
+	return s
+}
+
 func (s *sitesBuilder) WithLogger(logger *loggers.Logger) *sitesBuilder {
 	s.logger = logger
 	return s
@@ -502,6 +508,7 @@ func (s *sitesBuilder) LoadConfig() error {
 }
 
 func (s *sitesBuilder) CreateSitesE() error {
+
 	if !s.addNothing {
 		if _, ok := s.Fs.Source.(*afero.OsFs); ok {
 			for _, dir := range []string{
@@ -529,7 +536,6 @@ func (s *sitesBuilder) CreateSitesE() error {
 		s.writeFilePairs("data", s.dataFilePairs)
 		s.writeFilePairs("content", s.contentFilePairs)
 		s.writeFilePairs("layouts", s.templateFilePairs)
-
 	}
 
 	if err := s.LoadConfig(); err != nil {
@@ -677,7 +683,7 @@ hello:
 		}
 	)
 
-	if len(s.contentFilePairs) == 0 {
+	if len(s.contentFilePairs) == 0 && !s.addNoContent {
 		s.writeFilePairs("content", s.createFilenameContent(defaultContent))
 	}
 
diff --git a/resources/image_cache.go b/resources/image_cache.go
index 1888b457f59..3830af7d34d 100644
--- a/resources/image_cache.go
+++ b/resources/image_cache.go
@@ -18,7 +18,8 @@ import (
 	"io"
 	"path/filepath"
 	"strings"
-	"sync"
+
+	"github.com/gohugoio/hugo/cache/memcache"
 
 	"github.com/gohugoio/hugo/resources/images"
 
@@ -30,38 +31,31 @@ type imageCache struct {
 	pathSpec *helpers.PathSpec
 
 	fileCache *filecache.Cache
-
-	mu    sync.RWMutex
-	store map[string]*resourceAdapter
+	mCache    memcache.Getter
 }
 
 func (c *imageCache) deleteIfContains(s string) {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	s = c.normalizeKeyBase(s)
-	for k := range c.store {
-		if strings.Contains(k, s) {
-			delete(c.store, k)
-		}
-	}
+	// TODO1
+	/*	c.mu.Lock()
+		defer c.mu.Unlock()
+		s = c.normalizeKeyBase(s)
+		for k := range c.store {
+			if strings.Contains(k, s) {
+				delete(c.store, k)
+			}
+		}*/
 }
 
-// The cache key is a lowecase path with Unix style slashes and it always starts with
+// The cache key is a lowecase path with Unix style slashes and it never starts with
 // a leading slash.
 func (c *imageCache) normalizeKey(key string) string {
-	return "/" + c.normalizeKeyBase(key)
+	return c.normalizeKeyBase(key)
 }
 
 func (c *imageCache) normalizeKeyBase(key string) string {
 	return strings.Trim(strings.ToLower(filepath.ToSlash(key)), "/")
 }
 
-func (c *imageCache) clear() {
-	c.mu.Lock()
-	defer c.mu.Unlock()
-	c.store = make(map[string]*resourceAdapter)
-}
-
 func (c *imageCache) getOrCreate(
 	parent *imageResource, conf images.ImageConfig,
 	createImage func() (*imageResource, image.Image, error)) (*resourceAdapter, error) {
@@ -69,99 +63,90 @@ func (c *imageCache) getOrCreate(
 	memKey := parent.relTargetPathForRel(relTarget.path(), false, false, false)
 	memKey = c.normalizeKey(memKey)
 
-	// For the file cache we want to generate and store it once if possible.
-	fileKeyPath := relTarget
-	if fi := parent.root.getFileInfo(); fi != nil {
-		fileKeyPath.dir = filepath.ToSlash(filepath.Dir(fi.Meta().Path()))
-	}
-	fileKey := fileKeyPath.path()
+	v, err := c.mCache.GetOrCreate(memKey, func() (interface{}, error) {
+		// For the file cache we want to generate and store it once if possible.
+		fileKeyPath := relTarget
+		if fi := parent.root.getFileInfo(); fi != nil {
+			fileKeyPath.dir = filepath.ToSlash(filepath.Dir(fi.Meta().Path()))
+		}
+		fileKey := fileKeyPath.path()
 
-	// First check the in-memory store, then the disk.
-	c.mu.RLock()
-	cachedImage, found := c.store[memKey]
-	c.mu.RUnlock()
+		var img *imageResource
 
-	if found {
-		return cachedImage, nil
-	}
+		// These funcs are protected by a named lock.
+		// read clones the parent to its new name and copies
+		// the content to the destinations.
+		read := func(info filecache.ItemInfo, r io.ReadSeeker) error {
+			img = parent.clone(nil)
+			rp := img.getResourcePaths()
+			rp.relTargetDirFile.file = relTarget.file
+			img.setSourceFilename(info.Name)
 
-	var img *imageResource
+			if err := img.InitConfig(r); err != nil {
+				return err
+			}
 
-	// These funcs are protected by a named lock.
-	// read clones the parent to its new name and copies
-	// the content to the destinations.
-	read := func(info filecache.ItemInfo, r io.ReadSeeker) error {
-		img = parent.clone(nil)
-		rp := img.getResourcePaths()
-		rp.relTargetDirFile.file = relTarget.file
-		img.setSourceFilename(info.Name)
+			r.Seek(0, 0)
 
-		if err := img.InitConfig(r); err != nil {
-			return err
-		}
+			w, err := img.openDestinationsForWriting()
+			if err != nil {
+				return err
+			}
 
-		r.Seek(0, 0)
+			if w == nil {
+				// Nothing to write.
+				return nil
+			}
+
+			defer w.Close()
+			_, err = io.Copy(w, r)
 
-		w, err := img.openDestinationsForWriting()
-		if err != nil {
 			return err
 		}
 
-		if w == nil {
-			// Nothing to write.
-			return nil
-		}
+		// create creates the image and encodes it to the cache (w).
+		create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) {
+			defer w.Close()
 
-		defer w.Close()
-		_, err = io.Copy(w, r)
+			var conv image.Image
+			img, conv, err = createImage()
+			if err != nil {
+				return
+			}
+			rp := img.getResourcePaths()
+			rp.relTargetDirFile.file = relTarget.file
+			img.setSourceFilename(info.Name)
 
-		return err
-	}
+			return img.EncodeTo(conf, conv, w)
+		}
+
+		// Now look in the file cache.
 
-	// create creates the image and encodes it to the cache (w).
-	create := func(info filecache.ItemInfo, w io.WriteCloser) (err error) {
-		defer w.Close()
+		// The definition of this counter is not that we have processed that amount
+		// (e.g. resized etc.), it can be fetched from file cache,
+		//  but the count of processed image variations for this site.
+		c.pathSpec.ProcessingStats.Incr(&c.pathSpec.ProcessingStats.ProcessedImages)
 
-		var conv image.Image
-		img, conv, err = createImage()
+		_, err := c.fileCache.ReadOrCreate(fileKey, read, create)
 		if err != nil {
-			return
+			return nil, err
 		}
-		rp := img.getResourcePaths()
-		rp.relTargetDirFile.file = relTarget.file
-		img.setSourceFilename(info.Name)
 
-		return img.EncodeTo(conf, conv, w)
-	}
+		// The file is now stored in this cache.
+		img.setSourceFs(c.fileCache.Fs)
 
-	// Now look in the file cache.
+		imgAdapter := newResourceAdapter(parent.getSpec(), true, img)
 
-	// The definition of this counter is not that we have processed that amount
-	// (e.g. resized etc.), it can be fetched from file cache,
-	//  but the count of processed image variations for this site.
-	c.pathSpec.ProcessingStats.Incr(&c.pathSpec.ProcessingStats.ProcessedImages)
+		return imgAdapter, nil
+	})
 
-	_, err := c.fileCache.ReadOrCreate(fileKey, read, create)
 	if err != nil {
 		return nil, err
 	}
+	return v.(*resourceAdapter), nil
 
-	// The file is now stored in this cache.
-	img.setSourceFs(c.fileCache.Fs)
-
-	c.mu.Lock()
-	if cachedImage, found = c.store[memKey]; found {
-		c.mu.Unlock()
-		return cachedImage, nil
-	}
-
-	imgAdapter := newResourceAdapter(parent.getSpec(), true, img)
-	c.store[memKey] = imgAdapter
-	c.mu.Unlock()
-
-	return imgAdapter, nil
 }
 
-func newImageCache(fileCache *filecache.Cache, ps *helpers.PathSpec) *imageCache {
-	return &imageCache{fileCache: fileCache, pathSpec: ps, store: make(map[string]*resourceAdapter)}
+func newImageCache(fileCache *filecache.Cache, memCache *memcache.Cache, ps *helpers.PathSpec) *imageCache {
+	return &imageCache{fileCache: fileCache, mCache: memCache.GetOrCreatePartition("images", memcache.ClearNever), pathSpec: ps}
 }
diff --git a/resources/image_test.go b/resources/image_test.go
index f98d9f4bb24..2826ea98405 100644
--- a/resources/image_test.go
+++ b/resources/image_test.go
@@ -352,7 +352,7 @@ func TestImageResizeInSubPath(t *testing.T) {
 	c.Assert(spec.BaseFs.PublishFs.Remove(publishedImageFilename), qt.IsNil)
 
 	// Cleare mem cache to simulate reading from the file cache.
-	spec.imageCache.clear()
+	spec.imageCache.mCache.Clear()
 
 	resizedAgain, err := image.Resize("101x101")
 	c.Assert(err, qt.IsNil)
diff --git a/resources/post_publish.go b/resources/post_publish.go
index b2adfa5ce03..49b6fb82491 100644
--- a/resources/post_publish.go
+++ b/resources/post_publish.go
@@ -19,12 +19,13 @@ import (
 )
 
 type transformationKeyer interface {
-	TransformationKey() string
+	TransformationKey() (string, string)
 }
 
 // PostProcess wraps the given Resource for later processing.
 func (spec *Spec) PostProcess(r resource.Resource) (postpub.PostPublishedResource, error) {
-	key := r.(transformationKeyer).TransformationKey()
+	primary, secondary := r.(transformationKeyer).TransformationKey()
+	key := primary + secondary
 	spec.postProcessMu.RLock()
 	result, found := spec.PostProcessResources[key]
 	spec.postProcessMu.RUnlock()
diff --git a/resources/resource.go b/resources/resource.go
index acdf2d744ec..eb127292209 100644
--- a/resources/resource.go
+++ b/resources/resource.go
@@ -20,6 +20,7 @@ import (
 	"os"
 	"path"
 	"path/filepath"
+	"strings"
 	"sync"
 
 	"github.com/gohugoio/hugo/resources/internal"
@@ -172,8 +173,6 @@ func (commonResource) Slice(in interface{}) (interface{}, error) {
 				return nil, fmt.Errorf("type %T is not a Resource", v)
 			}
 			groups[i] = g
-			{
-			}
 		}
 		return groups, nil
 	default:
@@ -234,8 +233,12 @@ func (l *genericResource) Data() interface{} {
 	return l.data
 }
 
+// TODO1
 func (l *genericResource) Key() string {
-	return l.RelPermalink()
+	if l.spec.Paths.IsMultiHost {
+		return l.Permalink()
+	}
+	return strings.TrimPrefix(l.RelPermalink(), "/")
 }
 
 func (l *genericResource) MediaType() media.Type {
diff --git a/resources/resource_cache.go b/resources/resource_cache.go
index 47822a7f506..ff9dee65cf4 100644
--- a/resources/resource_cache.go
+++ b/resources/resource_cache.go
@@ -21,6 +21,8 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"github.com/gohugoio/hugo/helpers"
 
 	"github.com/gohugoio/hugo/hugofs/glob"
@@ -28,8 +30,6 @@ import (
 	"github.com/gohugoio/hugo/resources/resource"
 
 	"github.com/gohugoio/hugo/cache/filecache"
-
-	"github.com/BurntSushi/locker"
 )
 
 const (
@@ -42,13 +42,11 @@ type ResourceCache struct {
 
 	sync.RWMutex
 
-	// Either resource.Resource or resource.Resources.
-	cache map[string]interface{}
+	// Memory cache with either
+	// resource.Resource or resource.Resources.
+	cache memcache.Getter
 
 	fileCache *filecache.Cache
-
-	// Provides named resource locks.
-	nlocker *locker.Locker
 }
 
 // ResourceCacheKey converts the filename into the format used in the resource
@@ -123,42 +121,16 @@ func ResourceKeyContainsAny(key string, partitions []string) bool {
 	return false
 }
 
-func newResourceCache(rs *Spec) *ResourceCache {
+func newResourceCache(rs *Spec, memCache *memcache.Cache) *ResourceCache {
 	return &ResourceCache{
 		rs:        rs,
 		fileCache: rs.FileCaches.AssetsCache(),
-		cache:     make(map[string]interface{}),
-		nlocker:   locker.NewLocker(),
+		cache:     memCache.GetOrCreatePartition("resources", memcache.ClearOnRebuild),
 	}
 }
 
-func (c *ResourceCache) clear() {
-	c.Lock()
-	defer c.Unlock()
-
-	c.cache = make(map[string]interface{})
-	c.nlocker = locker.NewLocker()
-}
-
-func (c *ResourceCache) Contains(key string) bool {
-	key = c.cleanKey(filepath.ToSlash(key))
-	_, found := c.get(key)
-	return found
-}
-
-func (c *ResourceCache) cleanKey(key string) string {
-	return strings.TrimPrefix(path.Clean(strings.ToLower(key)), "/")
-}
-
-func (c *ResourceCache) get(key string) (interface{}, bool) {
-	c.RLock()
-	defer c.RUnlock()
-	r, found := c.cache[key]
-	return r, found
-}
-
 func (c *ResourceCache) GetOrCreate(key string, f func() (resource.Resource, error)) (resource.Resource, error) {
-	r, err := c.getOrCreate(key, func() (interface{}, error) { return f() })
+	r, err := c.cache.GetOrCreate(key, func() (interface{}, error) { return f() })
 	if r == nil || err != nil {
 		return nil, err
 	}
@@ -166,43 +138,14 @@ func (c *ResourceCache) GetOrCreate(key string, f func() (resource.Resource, err
 }
 
 func (c *ResourceCache) GetOrCreateResources(key string, f func() (resource.Resources, error)) (resource.Resources, error) {
-	r, err := c.getOrCreate(key, func() (interface{}, error) { return f() })
+	// TODO1
+	r, err := c.cache.GetOrCreate(key, func() (interface{}, error) { return f() })
 	if r == nil || err != nil {
 		return nil, err
 	}
 	return r.(resource.Resources), nil
 }
 
-func (c *ResourceCache) getOrCreate(key string, f func() (interface{}, error)) (interface{}, error) {
-	key = c.cleanKey(key)
-	// First check in-memory cache.
-	r, found := c.get(key)
-	if found {
-		return r, nil
-	}
-	// This is a potentially long running operation, so get a named lock.
-	c.nlocker.Lock(key)
-
-	// Double check in-memory cache.
-	r, found = c.get(key)
-	if found {
-		c.nlocker.Unlock(key)
-		return r, nil
-	}
-
-	defer c.nlocker.Unlock(key)
-
-	r, err := f()
-	if err != nil {
-		return nil, err
-	}
-
-	c.set(key, r)
-
-	return r, nil
-
-}
-
 func (c *ResourceCache) getFilenames(key string) (string, string) {
 	filenameMeta := key + ".json"
 	filenameContent := key + ".content"
@@ -256,42 +199,28 @@ func (c *ResourceCache) writeMeta(key string, meta transformedResourceMetadata)
 
 }
 
-func (c *ResourceCache) set(key string, r interface{}) {
-	c.Lock()
-	defer c.Unlock()
-	c.cache[key] = r
-}
-
 func (c *ResourceCache) DeletePartitions(partitions ...string) {
-	partitionsSet := map[string]bool{
-		// Always clear out the resources not matching any partition.
-		"other": true,
-	}
-	for _, p := range partitions {
-		partitionsSet[p] = true
-	}
+	// TODO1
+	/*
+		partitionsSet := map[string]bool{
+			// Always clear out the resources not matching any partition.
+			CACHE_OTHER: true,
+		}
+		for _, p := range partitions {
+			partitionsSet[p] = true
+		}
 
-	if partitionsSet[CACHE_CLEAR_ALL] {
-		c.clear()
-		return
-	}
+		// TODO1 move this method?
+		if partitionsSet[CACHE_CLEAR_ALL] {
+			c.cache.Clear()
+			return
+		}
 
-	c.Lock()
-	defer c.Unlock()
+		c.Lock()
+		defer c.Unlock()
 
-	for k := range c.cache {
-		clear := false
 		for p := range partitionsSet {
-			if strings.Contains(k, p) {
-				// There will be some false positive, but that's fine.
-				clear = true
-				break
-			}
+			c.cache.DeleteAll(p)
 		}
-
-		if clear {
-			delete(c.cache, k)
-		}
-	}
-
+	*/
 }
diff --git a/resources/resource_factories/bundler/bundler.go b/resources/resource_factories/bundler/bundler.go
index 1ea92bea397..04ba1579d7f 100644
--- a/resources/resource_factories/bundler/bundler.go
+++ b/resources/resource_factories/bundler/bundler.go
@@ -17,7 +17,6 @@ package bundler
 import (
 	"fmt"
 	"io"
-	"path"
 	"path/filepath"
 
 	"github.com/gohugoio/hugo/common/hugio"
@@ -82,7 +81,7 @@ func (r *multiReadSeekCloser) Close() error {
 // Concat concatenates the list of Resource objects.
 func (c *Client) Concat(targetPath string, r resource.Resources) (resource.Resource, error) {
 	// The CACHE_OTHER will make sure this will be re-created and published on rebuilds.
-	return c.rs.ResourceCache.GetOrCreate(path.Join(resources.CACHE_OTHER, targetPath), func() (resource.Resource, error) {
+	return c.rs.ResourceCache.GetOrCreate(targetPath, func() (resource.Resource, error) {
 		var resolvedm media.Type
 
 		// The given set of resources must be of the same Media Type.
diff --git a/resources/resource_factories/create/create.go b/resources/resource_factories/create/create.go
index 4ac20d36e5a..a6dcdba4a7f 100644
--- a/resources/resource_factories/create/create.go
+++ b/resources/resource_factories/create/create.go
@@ -18,7 +18,6 @@ package create
 import (
 	"path"
 	"path/filepath"
-	"strings"
 
 	"github.com/gohugoio/hugo/hugofs/glob"
 
@@ -74,13 +73,7 @@ func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, erro
 		name = "__match"
 	}
 
-	pattern = glob.NormalizePath(pattern)
-	partitions := glob.FilterGlobParts(strings.Split(pattern, "/"))
-	if len(partitions) == 0 {
-		partitions = []string{resources.CACHE_OTHER}
-	}
-	key := path.Join(name, path.Join(partitions...))
-	key = path.Join(key, pattern)
+	key := path.Join(name, glob.NormalizePath(pattern))
 
 	return c.rs.ResourceCache.GetOrCreateResources(key, func() (resource.Resources, error) {
 		var res resource.Resources
@@ -116,7 +109,7 @@ func (c *Client) match(pattern string, firstOnly bool) (resource.Resources, erro
 
 // FromString creates a new Resource from a string with the given relative target path.
 func (c *Client) FromString(targetPath, content string) (resource.Resource, error) {
-	return c.rs.ResourceCache.GetOrCreate(path.Join(resources.CACHE_OTHER, targetPath), func() (resource.Resource, error) {
+	return c.rs.ResourceCache.GetOrCreate(targetPath, func() (resource.Resource, error) {
 		return c.rs.New(
 			resources.ResourceSourceDescriptor{
 				Fs:          c.rs.FileCaches.AssetsCache().Fs,
diff --git a/resources/resource_metadata_test.go b/resources/resource_metadata_test.go
index c79a5002121..0414127b92a 100644
--- a/resources/resource_metadata_test.go
+++ b/resources/resource_metadata_test.go
@@ -209,12 +209,12 @@ func TestAssignMetadata(t *testing.T) {
 		}},
 	} {
 
-		foo2 = spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType)
-		logo2 = spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType)
-		foo1 = spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType)
-		logo1 = spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType)
-		foo3 = spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)
-		logo3 = spec.newGenericResource(nil, nil, nil, "/b/logo3.png", "logo3.png", pngType)
+		foo2 = newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType)
+		logo2 = newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType)
+		foo1 = newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType)
+		logo1 = newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType)
+		foo3 = newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)
+		logo3 = newGenericResource(spec, nil, nil, nil, "/b/logo3.png", "logo3.png", pngType)
 
 		resources = resource.Resources{
 			foo2,
diff --git a/resources/resource_spec.go b/resources/resource_spec.go
index 81eed2f0203..09fcc365b34 100644
--- a/resources/resource_spec.go
+++ b/resources/resource_spec.go
@@ -23,6 +23,8 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"github.com/gohugoio/hugo/common/herrors"
 
 	"github.com/gohugoio/hugo/config"
@@ -46,6 +48,7 @@ import (
 func NewSpec(
 	s *helpers.PathSpec,
 	fileCaches filecache.Caches,
+	memCache *memcache.Cache,
 	incr identity.Incrementer,
 	logger *loggers.Logger,
 	errorHandler herrors.ErrorSender,
@@ -89,11 +92,11 @@ func NewSpec(
 		PostProcessResources: make(map[string]postpub.PostPublishedResource),
 		imageCache: newImageCache(
 			fileCaches.ImageCache(),
-
+			memCache,
 			s,
 		)}
 
-	rs.ResourceCache = newResourceCache(rs)
+	rs.ResourceCache = newResourceCache(rs, memCache)
 
 	return rs, nil
 
@@ -129,29 +132,7 @@ func (r *Spec) New(fd ResourceSourceDescriptor) (resource.Resource, error) {
 	return r.newResourceFor(fd)
 }
 
-func (r *Spec) CacheStats() string {
-	r.imageCache.mu.RLock()
-	defer r.imageCache.mu.RUnlock()
-
-	s := fmt.Sprintf("Cache entries: %d", len(r.imageCache.store))
-
-	count := 0
-	for k := range r.imageCache.store {
-		if count > 5 {
-			break
-		}
-		s += "\n" + k
-		count++
-	}
-
-	return s
-}
-
-func (r *Spec) ClearCaches() {
-	r.imageCache.clear()
-	r.ResourceCache.clear()
-}
-
+// TODO1
 func (r *Spec) DeleteBySubstring(s string) {
 	r.imageCache.deleteIfContains(s)
 }
@@ -161,25 +142,6 @@ func (s *Spec) String() string {
 }
 
 // TODO(bep) clean up below
-func (r *Spec) newGenericResource(sourceFs afero.Fs,
-	targetPathBuilder func() page.TargetPaths,
-	osFileInfo os.FileInfo,
-	sourceFilename,
-	baseFilename string,
-	mediaType media.Type) *genericResource {
-	return r.newGenericResourceWithBase(
-		sourceFs,
-		nil,
-		nil,
-		targetPathBuilder,
-		osFileInfo,
-		sourceFilename,
-		baseFilename,
-		mediaType,
-	)
-
-}
-
 func (r *Spec) newGenericResourceWithBase(
 	sourceFs afero.Fs,
 	openReadSeekerCloser resource.OpenReadSeekCloser,
diff --git a/resources/resource_test.go b/resources/resource_test.go
index 7a0b8069d79..75ac94f79ce 100644
--- a/resources/resource_test.go
+++ b/resources/resource_test.go
@@ -34,7 +34,7 @@ func TestGenericResource(t *testing.T) {
 	c := qt.New(t)
 	spec := newTestResourceSpec(specDescriptor{c: c})
 
-	r := spec.newGenericResource(nil, nil, nil, "/a/foo.css", "foo.css", media.CSSType)
+	r := newGenericResource(spec, nil, nil, nil, "/a/foo.css", "foo.css", media.CSSType)
 
 	c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo.css")
 	c.Assert(r.RelPermalink(), qt.Equals, "/foo.css")
@@ -48,11 +48,11 @@ func TestGenericResourceWithLinkFacory(t *testing.T) {
 
 	factory := newTargetPaths("/foo")
 
-	r := spec.newGenericResource(nil, factory, nil, "/a/foo.css", "foo.css", media.CSSType)
+	r := newGenericResource(spec, nil, factory, nil, "/a/foo.css", "foo.css", media.CSSType)
 
 	c.Assert(r.Permalink(), qt.Equals, "https://example.com/foo/foo.css")
 	c.Assert(r.RelPermalink(), qt.Equals, "/foo/foo.css")
-	c.Assert(r.Key(), qt.Equals, "/foo/foo.css")
+	c.Assert(r.Key(), qt.Equals, "foo/foo.css")
 	c.Assert(r.ResourceType(), qt.Equals, "css")
 }
 
@@ -105,10 +105,10 @@ func TestResourcesByType(t *testing.T) {
 	c := qt.New(t)
 	spec := newTestResourceSpec(specDescriptor{c: c})
 	resources := resource.Resources{
-		spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/a/logo.png", "logo.css", pngType),
-		spec.newGenericResource(nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType)}
+		newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/a/logo.png", "logo.css", pngType),
+		newGenericResource(spec, nil, nil, nil, "/a/foo2.css", "foo2.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/a/foo3.css", "foo3.css", media.CSSType)}
 
 	c.Assert(len(resources.ByType("css")), qt.Equals, 3)
 	c.Assert(len(resources.ByType("image")), qt.Equals, 1)
@@ -119,11 +119,11 @@ func TestResourcesGetByPrefix(t *testing.T) {
 	c := qt.New(t)
 	spec := newTestResourceSpec(specDescriptor{c: c})
 	resources := resource.Resources{
-		spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
-		spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType),
-		spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)}
+		newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
+		newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType),
+		newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType)}
 
 	c.Assert(resources.GetMatch("asdf*"), qt.IsNil)
 	c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png")
@@ -148,14 +148,14 @@ func TestResourcesGetMatch(t *testing.T) {
 	c := qt.New(t)
 	spec := newTestResourceSpec(specDescriptor{c: c})
 	resources := resource.Resources{
-		spec.newGenericResource(nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
-		spec.newGenericResource(nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType),
-		spec.newGenericResource(nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/b/c/foo4.css", "c/foo4.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/b/c/foo5.css", "c/foo5.css", media.CSSType),
-		spec.newGenericResource(nil, nil, nil, "/b/c/d/foo6.css", "c/d/foo6.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/a/foo1.css", "foo1.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/a/logo1.png", "logo1.png", pngType),
+		newGenericResource(spec, nil, nil, nil, "/b/Logo2.png", "Logo2.png", pngType),
+		newGenericResource(spec, nil, nil, nil, "/b/foo2.css", "foo2.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/b/foo3.css", "foo3.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/b/c/foo4.css", "c/foo4.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/b/c/foo5.css", "c/foo5.css", media.CSSType),
+		newGenericResource(spec, nil, nil, nil, "/b/c/d/foo6.css", "c/d/foo6.css", media.CSSType),
 	}
 
 	c.Assert(resources.GetMatch("logo*").RelPermalink(), qt.Equals, "/logo1.png")
@@ -212,7 +212,7 @@ func BenchmarkResourcesMatchA100(b *testing.B) {
 	a100 := strings.Repeat("a", 100)
 	pattern := "a*a*a*a*a*a*a*a*b"
 
-	resources := resource.Resources{spec.newGenericResource(nil, nil, nil, "/a/"+a100, a100, media.CSSType)}
+	resources := resource.Resources{newGenericResource(spec, nil, nil, nil, "/a/"+a100, a100, media.CSSType)}
 
 	b.ResetTimer()
 	for i := 0; i < b.N; i++ {
@@ -228,17 +228,17 @@ func benchResources(b *testing.B) resource.Resources {
 
 	for i := 0; i < 30; i++ {
 		name := fmt.Sprintf("abcde%d_%d.css", i%5, i)
-		resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType))
+		resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType))
 	}
 
 	for i := 0; i < 30; i++ {
 		name := fmt.Sprintf("efghi%d_%d.css", i%5, i)
-		resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType))
+		resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType))
 	}
 
 	for i := 0; i < 30; i++ {
 		name := fmt.Sprintf("jklmn%d_%d.css", i%5, i)
-		resources = append(resources, spec.newGenericResource(nil, nil, nil, "/b/sub/"+name, "sub/"+name, media.CSSType))
+		resources = append(resources, newGenericResource(spec, nil, nil, nil, "/b/sub/"+name, "sub/"+name, media.CSSType))
 	}
 
 	return resources
@@ -266,7 +266,7 @@ func BenchmarkAssignMetadata(b *testing.B) {
 		}
 		for i := 0; i < 20; i++ {
 			name := fmt.Sprintf("foo%d_%d.css", i%5, i)
-			resources = append(resources, spec.newGenericResource(nil, nil, nil, "/a/"+name, name, media.CSSType))
+			resources = append(resources, newGenericResource(spec, nil, nil, nil, "/a/"+name, name, media.CSSType))
 		}
 		b.StartTimer()
 
diff --git a/resources/resource_transformers/htesting/testhelpers.go b/resources/resource_transformers/htesting/testhelpers.go
index 8eacf7da4e6..3d7af38c23d 100644
--- a/resources/resource_transformers/htesting/testhelpers.go
+++ b/resources/resource_transformers/htesting/testhelpers.go
@@ -16,6 +16,8 @@ package htesting
 import (
 	"path/filepath"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"github.com/gohugoio/hugo/cache/filecache"
 	"github.com/gohugoio/hugo/helpers"
 	"github.com/gohugoio/hugo/hugofs"
@@ -51,7 +53,7 @@ func NewTestResourceSpec() (*resources.Spec, error) {
 		return nil, err
 	}
 
-	spec, err := resources.NewSpec(s, filecaches, nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
+	spec, err := resources.NewSpec(s, filecaches, memcache.New(memcache.Config{}), nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
 	return spec, err
 }
 
diff --git a/resources/testhelpers_test.go b/resources/testhelpers_test.go
index 0462f7ecdfc..3f5d6905f06 100644
--- a/resources/testhelpers_test.go
+++ b/resources/testhelpers_test.go
@@ -4,6 +4,8 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"image"
 	"io"
 	"io/ioutil"
@@ -90,7 +92,9 @@ func newTestResourceSpec(desc specDescriptor) *Spec {
 	filecaches, err := filecache.NewCaches(s)
 	c.Assert(err, qt.IsNil)
 
-	spec, err := NewSpec(s, filecaches, nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
+	mc := memcache.New(memcache.Config{})
+
+	spec, err := NewSpec(s, filecaches, mc, nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
 	c.Assert(err, qt.IsNil)
 	return spec
 }
@@ -129,7 +133,7 @@ func newTestResourceOsFs(c *qt.C) (*Spec, string) {
 	filecaches, err := filecache.NewCaches(s)
 	c.Assert(err, qt.IsNil)
 
-	spec, err := NewSpec(s, filecaches, nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
+	spec, err := NewSpec(s, filecaches, memcache.New(memcache.Config{}), nil, nil, nil, output.DefaultFormats, media.DefaultTypes)
 	c.Assert(err, qt.IsNil)
 
 	return spec, workDir
@@ -207,3 +211,22 @@ func writeToFs(t testing.TB, fs afero.Fs, filename, content string) {
 		t.Fatalf("Failed to write file: %s", err)
 	}
 }
+
+func newGenericResource(r *Spec, sourceFs afero.Fs,
+	targetPathBuilder func() page.TargetPaths,
+	osFileInfo os.FileInfo,
+	sourceFilename,
+	baseFilename string,
+	mediaType media.Type) *genericResource {
+	return r.newGenericResourceWithBase(
+		sourceFs,
+		nil,
+		nil,
+		targetPathBuilder,
+		osFileInfo,
+		sourceFilename,
+		baseFilename,
+		mediaType,
+	)
+
+}
diff --git a/resources/transform.go b/resources/transform.go
index 98aee3c2a6f..46b1de08ac1 100644
--- a/resources/transform.go
+++ b/resources/transform.go
@@ -296,7 +296,7 @@ func (r *resourceAdapter) publish() {
 
 }
 
-func (r *resourceAdapter) TransformationKey() string {
+func (r *resourceAdapter) TransformationKey() (string, string) {
 	// Files with a suffix will be stored in cache (both on disk and in memory)
 	// partitioned by their suffix.
 	var key string
@@ -304,35 +304,27 @@ func (r *resourceAdapter) TransformationKey() string {
 		key = key + "_" + tr.Key().Value()
 	}
 
-	base := ResourceCacheKey(r.target.Key())
-	return r.spec.ResourceCache.cleanKey(base) + "_" + helpers.MD5String(key)
+	return "TODO1", ResourceCacheKey(r.target.Key()) + "_" + helpers.MD5String(key)
 }
 
-func (r *resourceAdapter) transform(publish, setContent bool) error {
-	cache := r.spec.ResourceCache
-
-	key := r.TransformationKey()
-
-	cached, found := cache.get(key)
+func (r *resourceAdapter) getOrTransform(publish, setContent bool) error {
+	_, key := r.TransformationKey()
+	res, err := r.spec.ResourceCache.cache.GetOrCreate(key, func() (interface{}, error) {
+		return r.transform2(key, publish, setContent)
+	})
 
-	if found {
-		r.resourceAdapterInner = cached.(*resourceAdapterInner)
-		return nil
+	if err != nil {
+		return err
 	}
 
-	// Acquire a write lock for the named transformation.
-	cache.nlocker.Lock(key)
-	// Check the cache again.
-	cached, found = cache.get(key)
-	if found {
-		r.resourceAdapterInner = cached.(*resourceAdapterInner)
-		cache.nlocker.Unlock(key)
-		return nil
-	}
+	r.resourceAdapterInner = res.(*resourceAdapterInner)
+
+	return nil
 
-	defer cache.nlocker.Unlock(key)
-	defer cache.set(key, r.resourceAdapterInner)
+}
 
+func (r *resourceAdapter) transform2(key string, publish, setContent bool) (*resourceAdapterInner, error) {
+	cache := r.spec.ResourceCache
 	b1 := bp.GetBuffer()
 	b2 := bp.GetBuffer()
 	defer bp.PutBuffer(b1)
@@ -353,7 +345,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 
 	contentrc, err := contentReadSeekerCloser(r.target)
 	if err != nil {
-		return err
+		return nil, err
 	}
 
 	defer contentrc.Close()
@@ -426,21 +418,21 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 		} else {
 			err = tr.Transform(tctx)
 			if err != nil && err != herrors.ErrFeatureNotAvailable {
-				return newErr(err)
+				return nil, newErr(err)
 			}
 
 			if mayBeCachedOnDisk {
 				tryFileCache = r.spec.BuildConfig.UseResourceCache(err)
 			}
 			if err != nil && !tryFileCache {
-				return newErr(err)
+				return nil, newErr(err)
 			}
 		}
 
 		if tryFileCache {
 			f := r.target.tryTransformedFileCache(key, updates)
 			if f == nil {
-				return newErr(errors.Errorf("resource %q not found in file cache", key))
+				return nil, newErr(errors.Errorf("resource %q not found in file cache", key))
 			}
 			transformedContentr = f
 			updates.sourceFs = cache.fileCache.Fs
@@ -465,7 +457,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 	if publish {
 		publicw, err := r.target.openPublishFileForWriting(updates.targetPath)
 		if err != nil {
-			return err
+			return nil, err
 		}
 		publishwriters = append(publishwriters, publicw)
 	}
@@ -475,7 +467,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 			// Also write it to the cache
 			fi, metaw, err := cache.writeMeta(key, updates.toTransformedResourceMetadata())
 			if err != nil {
-				return err
+				return nil, err
 			}
 			updates.sourceFilename = &fi.Name
 			updates.sourceFs = cache.fileCache.Fs
@@ -506,7 +498,7 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 	publishw := hugio.NewMultiWriteCloser(publishwriters...)
 	_, err = io.Copy(publishw, transformedContentr)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	publishw.Close()
 
@@ -517,11 +509,11 @@ func (r *resourceAdapter) transform(publish, setContent bool) error {
 
 	newTarget, err := r.target.cloneWithUpdates(updates)
 	if err != nil {
-		return err
+		return nil, err
 	}
 	r.target = newTarget
 
-	return nil
+	return r.resourceAdapterInner, nil
 }
 
 func (r *resourceAdapter) init(publish, setContent bool) {
@@ -541,7 +533,7 @@ func (r *resourceAdapter) initTransform(publish, setContent bool) {
 			r.publishOnce = nil
 		}
 
-		r.transformationsErr = r.transform(publish, setContent)
+		r.transformationsErr = r.getOrTransform(publish, setContent)
 		if r.transformationsErr != nil {
 			if r.spec.ErrorSender != nil {
 				r.spec.ErrorSender.SendError(r.transformationsErr)
diff --git a/tpl/openapi/openapi3/openapi3.go b/tpl/openapi/openapi3/openapi3.go
index 7dfd2f6a797..a6942286a9a 100644
--- a/tpl/openapi/openapi3/openapi3.go
+++ b/tpl/openapi/openapi3/openapi3.go
@@ -21,7 +21,7 @@ import (
 	"github.com/pkg/errors"
 
 	kopenapi3 "github.com/getkin/kin-openapi/openapi3"
-	"github.com/gohugoio/hugo/cache/namedmemcache"
+	"github.com/gohugoio/hugo/cache/memcache"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/parser/metadecoders"
 	"github.com/gohugoio/hugo/resources/resource"
@@ -29,22 +29,15 @@ import (
 
 // New returns a new instance of the openapi3-namespaced template functions.
 func New(deps *deps.Deps) *Namespace {
-	// TODO1 consolidate when merging that "other branch" -- but be aware of the keys.
-	cache := namedmemcache.New()
-	deps.BuildStartListeners.Add(
-		func() {
-			cache.Clear()
-		})
-
 	return &Namespace{
-		cache: cache,
+		cache: deps.MemCache.GetOrCreatePartition("openapi3", memcache.ClearOnRebuild),
 		deps:  deps,
 	}
 }
 
 // Namespace provides template functions for the "openapi3".
 type Namespace struct {
-	cache *namedmemcache.Cache
+	cache memcache.Getter
 	deps  *deps.Deps
 }
 
diff --git a/tpl/transform/init_test.go b/tpl/transform/init_test.go
index 47bd8a391e6..393b6b140d8 100644
--- a/tpl/transform/init_test.go
+++ b/tpl/transform/init_test.go
@@ -16,6 +16,8 @@ package transform
 import (
 	"testing"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	qt "github.com/frankban/quicktest"
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/htesting/hqt"
@@ -28,7 +30,9 @@ func TestInit(t *testing.T) {
 	var ns *internal.TemplateFuncsNamespace
 
 	for _, nsf := range internal.TemplateFuncsNamespaceRegistry {
-		ns = nsf(&deps.Deps{})
+		ns = nsf(&deps.Deps{
+			MemCache: memcache.New(memcache.Config{}),
+		})
 		if ns.Name == name {
 			found = true
 			break
diff --git a/tpl/transform/transform.go b/tpl/transform/transform.go
index b168d2a50d4..1365b75d079 100644
--- a/tpl/transform/transform.go
+++ b/tpl/transform/transform.go
@@ -18,7 +18,7 @@ import (
 	"html"
 	"html/template"
 
-	"github.com/gohugoio/hugo/cache/namedmemcache"
+	"github.com/gohugoio/hugo/cache/memcache"
 
 	"github.com/gohugoio/hugo/deps"
 	"github.com/gohugoio/hugo/helpers"
@@ -27,22 +27,19 @@ import (
 
 // New returns a new instance of the transform-namespaced template functions.
 func New(deps *deps.Deps) *Namespace {
-	cache := namedmemcache.New()
-	deps.BuildStartListeners.Add(
-		func() {
-			cache.Clear()
-		})
-
+	if deps.MemCache == nil {
+		panic("must provide MemCache")
+	}
 	return &Namespace{
-		cache: cache,
 		deps:  deps,
+		cache: deps.MemCache.GetOrCreatePartition("tpl/transform", memcache.ClearOnRebuild),
 	}
 }
 
 // Namespace provides template functions for the "transform" namespace.
 type Namespace struct {
-	cache *namedmemcache.Cache
 	deps  *deps.Deps
+	cache memcache.Getter
 }
 
 // Emojify returns a copy of s with all emoji codes replaced with actual emojis.
diff --git a/tpl/transform/transform_test.go b/tpl/transform/transform_test.go
index b3f4206ff6b..1a14661f246 100644
--- a/tpl/transform/transform_test.go
+++ b/tpl/transform/transform_test.go
@@ -16,6 +16,8 @@ package transform
 import (
 	"html/template"
 
+	"github.com/gohugoio/hugo/cache/memcache"
+
 	"testing"
 
 	"github.com/gohugoio/hugo/common/loggers"
@@ -251,6 +253,7 @@ func newDeps(cfg config.Provider) *deps.Deps {
 	return &deps.Deps{
 		Cfg:         cfg,
 		Fs:          hugofs.NewMem(l),
+		MemCache:    memcache.New(memcache.Config{}),
 		ContentSpec: cs,
 	}
 }
diff --git a/tpl/transform/unmarshal_test.go b/tpl/transform/unmarshal_test.go
index 183bdefd5bc..8796cef3724 100644
--- a/tpl/transform/unmarshal_test.go
+++ b/tpl/transform/unmarshal_test.go
@@ -145,7 +145,7 @@ a;b;c`, mime: media.CSVType}, map[string]interface{}{"DElimiter": ";", "Comment"
 		{tstNoStringer{}, nil, false},
 	} {
 
-		ns.cache.Clear()
+		ns.deps.MemCache.Clear()
 
 		var args []interface{}