Remove SetFinalizer from impl/memory.

impl/memory/datastore_test.go

 // Copyright 2015 The LUCI Authors. All rights reserved.
 // Use of this source code is governed under the Apache License, Version 2.0
 // that can be found in the LICENSE file.
 
 package memory
 
 import (
         "errors"
+        "flag"
         "fmt"
+        "runtime"
         "testing"
         "time"
 
         ds "github.com/luci/gae/service/datastore"
         "github.com/luci/gae/service/datastore/serialize"
         infoS "github.com/luci/gae/service/info"
 
         "golang.org/x/net/context"
 
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
+var enableMemoryTest = flag.Bool("test.memusage", false, "Enable memory usage test.")
+
 type MetaGroup struct {
         _id    int64   `gae:"$id,1"`
         _kind  string  `gae:"$kind,__entity_group__"`
         Parent *ds.Key `gae:"$parent"`
 
         Version int64 `gae:"__version__"`
 }
 
 func testGetMeta(c context.Context, k *ds.Key) int64 {
         mg := &MetaGroup{Parent: k.Root()}
@@ skipping 775 matching lines @@
                         // Add "foos" to a new namespace, then confirm that it gets indexed.
                         So(ds.Put(infoS.MustNamespace(ctx, "qux"), foos), ShouldBeNil)
                         ds.GetTestable(ctx).CatchupIndexes()
 
                         results = nil
                         So(ds.GetAll(infoS.MustNamespace(ctx, "qux"), q, &results), ShouldBeNil)
                         So(len(results), ShouldEqual, 2)
                 })
         })
 }
+
+// TestMemoryUsage performs a series of datastore operations, profiling the
+// memory usage before and after.
+//
+// This is an expensive test, and it's not really sufficiently deterministic to
+// be enabled by default. If you want to run this, use the '-test.memusage'
+// flag.
+func TestMemoryUsage(t *testing.T) {
+        if !*enableMemoryTest {
+                return
+        }
+
+        Convey("A datastore instance does not leak memory.", t, func() {
+                const rounds, items = 10, 200
+
+                // Initial memory stats.
+                var ms runtime.MemStats
+                runtime.MemProfileRate = 1
+                runtime.GC()
+                runtime.ReadMemStats(&ms)
+                initialAlloc := ms.Alloc
+
+                // Run the memory test entirely within its own function scope. This will
+                // provide a hard boundary where all associated resources should be
+                // free-able.
+                func() {
+                        c := Use(context.Background())
+                        for i := 0; i < rounds; i++ {
+                                toPut := make([]ds.PropertyMap, items)
+                                for j := range toPut {
+                                        toPut[j] = ds.PropertyMap{
+                                                "$kind": ds.MkProperty(fmt.Sprintf("kind-%d", j)),
+                                                "$id":   ds.MkProperty(1),
+                                        }
+                                }
+                                if err := ds.Put(c, toPut); err != nil {
+                                        panic(err)
+                                }
+
+                                runtime.GC()
+                        }
+                }()
+
+                for i := 0; i < 3; i++ {
+                        time.Sleep(100 * time.Millisecond)
+                        runtime.GC()
+                }
+                runtime.ReadMemStats(&ms)
+
+                t.Logf("Memory alloc difference is: %d", ms.Alloc-initialAlloc)
+        })
+}