Add -editor=true flag & invoke FreeOSMemory periodically (lower memory consumption)

To try this change out:

1. `git checkout sg/mem` to the exact commit.
2. `go install github.com/sourcegraph/go-langserver`
3. Open some Go code and hover over a symbol, then make an edit, then hover, repeat... (each edit and hover triggers type-checking again).
4. For now, you can also set `"go.languageServerFlags": ["-editor=false"]` in VS Code settings to try without this change (to compare memory usage).

With `code github.com/docker/docker/cmd/dockerd/docker.go`, and making 10 edits/hovers, the change is:

| Real Before | Real After | Real Change | Go Before | Go After | Go Change |
|-------------|------------|-------------|-----------|----------|-----------|
| 7.61GB      | 4.12GB     | -45.86%     | 3.92GB    | 3.33GB   | -15.05%   |

Where `Real` means real memory reported by OS X Activity Monitor, and `Go` means memory reported by Go as being in use.

TL;DR: 46% less memory consumption for users running with the vscode-go extension.

Author: Stephen Gutekanst

langserver/handler.go

@@ -20,9 +20,9 @@ import (
 )
 
 // NewHandler creates a Go language server handler.
-func NewHandler() jsonrpc2.Handler {
+func NewHandler(editor bool) jsonrpc2.Handler {
 	return lspHandler{jsonrpc2.HandlerWithError((&LangHandler{
-		HandlerShared: &HandlerShared{},
+		HandlerShared: &HandlerShared{editor: editor},
 	}).handle)}
 }
 

langserver/handler_shared.go

@@ -14,6 +14,7 @@ type HandlerShared struct {
 	Mu     sync.Mutex // guards all fields
 	Shared bool       // true if this struct is shared with a build server
 	FS     *AtomicFS  // full filesystem (mounts both deps and overlay)
+	editor bool       // running in local editor environment
 
 	// FindPackage if non-nil is used by our typechecker. See
 	// loader.Config.FindPackage. We use this in production to lazily

langserver/loader.go

@@ -11,7 +11,10 @@ import (
 	"log"
 	"path/filepath"
 	"reflect"
+	"runtime/debug"
 	"strings"
+	"sync"
+	"time"
 
 	opentracing "github.com/opentracing/opentracing-go"
 
@@ -204,7 +207,7 @@ func (h *LangHandler) cachedTypecheck(ctx context.Context, bctx *build.Context,
 		res := &typecheckResult{
 			fset: token.NewFileSet(),
 		}
-		res.prog, diags, res.err = typecheck(ctx, res.fset, bctx, bpkg, h.getFindPackageFunc())
+		res.prog, diags, res.err = typecheck(ctx, res.fset, bctx, bpkg, h.getFindPackageFunc(), h.HandlerShared.editor)
 		return res
 	})
 	if r == nil {
@@ -216,7 +219,10 @@ func (h *LangHandler) cachedTypecheck(ctx context.Context, bctx *build.Context,
 }
 
 // TODO(sqs): allow typechecking just a specific file not in a package, too
-func typecheck(ctx context.Context, fset *token.FileSet, bctx *build.Context, bpkg *build.Package, findPackage FindPackageFunc) (*loader.Program, diagnostics, error) {
+func typecheck(ctx context.Context, fset *token.FileSet, bctx *build.Context, bpkg *build.Package, findPackage FindPackageFunc, editor bool) (*loader.Program, diagnostics, error) {
+	if editor {
+		freeOSMemory()
+	}
 	var typeErrs []error
 	conf := loader.Config{
 		Fset: fset,
@@ -306,3 +312,47 @@ func isMultiplePackageError(err error) bool {
 	_, ok := err.(*build.MultiplePackageError)
 	return ok
 }
+
+var freeOSMemoryOnce sync.Once
+
+// freeOSMemory spawns a goroutine (only once) which invokes
+// runtime/debug.FreeOSMemory() more aggressively than the runtime default of
+// 5 minutes after GC.
+//
+// There is a long-standing known issue with Go in which memory is not returned
+// to the OS aggressively enough[1], which coincidently harms our application
+// quite a lot because we perform so many short-burst heap allocations during
+// the type-checking phase.
+//
+// This function should only be invoked in editor mode, not in sourcegraph.com
+// mode, because users running the language server as part of their editor
+// generally expect much lower memory usage. In contrast, on sourcegraph.com we
+// can give our servers plenty of RAM and allow Go to consume as much as it
+// wants. Go does reuse the memory not free'd to the OS, and as such enabling
+// this does _technically_ make our application perform less optimally -- but
+// in practice this has no observable affect in editor mode.
+//
+// The end effect of performing this is that repeating "hover over code" -> "make an edit"
+// 10 times inside a large package like github.com/docker/docker/cmd/dockerd:
+//
+//
+// 	| Real Before | Real After | Real Change | Go Before | Go After | Go Change |
+// 	|-------------|------------|-------------|-----------|----------|-----------|
+// 	| 7.61GB      | 4.12GB     | -45.86%     | 3.92GB    | 3.33GB   | -15.05%   |
+//
+// Where `Real` means real memory reported by OS X Activity Monitor, and `Go`
+// means memory reported by Go as being in use.
+//
+// TL;DR: 46% less memory consumption for users running with the vscode-go extension.
+//
+// [1] https://github.com/golang/go/issues/14735#issuecomment-194470114
+func freeOSMemory() {
+	freeOSMemoryOnce.Do(func() {
+		go func() {
+			for {
+				time.Sleep(1 * time.Second)
+				debug.FreeOSMemory()
+			}
+		}()
+	})
+}

main.go

@@ -23,6 +23,7 @@ var (
 	logfile      = flag.String("logfile", "", "also log to this file (in addition to stderr)")
 	printVersion = flag.Bool("version", false, "print version and exit")
 	pprof        = flag.String("pprof", ":6060", "start a pprof http server (https://golang.org/pkg/net/http/pprof/)")
+	editor       = flag.Bool("editor", true, "run the server in an editor-based local environment")
 )
 
 // version is the version field we report back. If you are releasing a new version:
@@ -87,12 +88,12 @@ func run() error {
 			if err != nil {
 				return err
 			}
-			jsonrpc2.NewConn(context.Background(), jsonrpc2.NewBufferedStream(conn, jsonrpc2.VSCodeObjectCodec{}), langserver.NewHandler(), connOpt...)
+			jsonrpc2.NewConn(context.Background(), jsonrpc2.NewBufferedStream(conn, jsonrpc2.VSCodeObjectCodec{}), langserver.NewHandler(*editor), connOpt...)
 		}
 
 	case "stdio":
 		log.Println("langserver-go: reading on stdin, writing on stdout")
-		<-jsonrpc2.NewConn(context.Background(), jsonrpc2.NewBufferedStream(stdrwc{}, jsonrpc2.VSCodeObjectCodec{}), langserver.NewHandler(), connOpt...).DisconnectNotify()
+		<-jsonrpc2.NewConn(context.Background(), jsonrpc2.NewBufferedStream(stdrwc{}, jsonrpc2.VSCodeObjectCodec{}), langserver.NewHandler(*editor), connOpt...).DisconnectNotify()
 		log.Println("connection closed")
 		return nil