interanal/core/runtime: move building logic from cue package
- Simplify logic
- Lazy load packages
- Cleanup interim types used for cue package transition
The lazy loading of builtin packages allows:
- adding builtin packages to a used Runtime
- isolate performance measurements and metrics for
CUE code that doesn't use imports.
Change-Id: Idd4578100047f83397be7c1d69f66b083974e6c0
Reviewed-on: https://cue-review.googlesource.com/c/cue/+/7421
Reviewed-by: CUE cueckoo <cueckoo@gmail.com>
Reviewed-by: Marcel van Lohuizen <mpvl@golang.org>
diff --git a/internal/core/runtime/build.go b/internal/core/runtime/build.go
new file mode 100644
index 0000000..c167e16
--- /dev/null
+++ b/internal/core/runtime/build.go
@@ -0,0 +1,94 @@
+// Copyright 2020 CUE Authors
+//
+// 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 runtime
+
+import (
+ "strings"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/cue/ast/astutil"
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/internal/core/adt"
+ "cuelang.org/go/internal/core/compile"
+)
+
+// Build builds b and all its transitive dependencies, insofar they have not
+// been build yet.
+func (x *Runtime) Build(b *build.Instance) (v *adt.Vertex, errs errors.Error) {
+ if v := x.GetNodeFromInstance(b); v != nil {
+ return v, b.Err
+ }
+ // TODO: clear cache of old implementation.
+ // if s := b.ImportPath; s != "" {
+ // // Use cached result, if available.
+ // if v, err := x.LoadImport(s); v != nil || err != nil {
+ // return v, err
+ // }
+ // }
+
+ errs = b.Err
+
+ // Build transitive dependencies.
+ for _, file := range b.Files {
+ file.VisitImports(func(d *ast.ImportDecl) {
+ for _, s := range d.Specs {
+ errs = errors.Append(errs, x.buildSpec(b, s))
+ }
+ })
+ }
+
+ err := x.ResolveFiles(b)
+ errs = errors.Append(errs, err)
+
+ v, err = compile.Files(nil, x, b.ID(), b.Files...)
+ errs = errors.Append(errs, err)
+
+ if errs != nil {
+ v = adt.ToVertex(&adt.Bottom{Err: errs})
+ b.Err = errs
+ }
+
+ x.AddInst(b.ImportPath, v, b)
+
+ return v, errs
+}
+
+func (x *Runtime) buildSpec(b *build.Instance, spec *ast.ImportSpec) (errs errors.Error) {
+ info, err := astutil.ParseImportSpec(spec)
+ if err != nil {
+ return errors.Promote(err, "invalid import path")
+ }
+
+ pkg := b.LookupImport(info.ID)
+ if pkg == nil {
+ if strings.Contains(info.ID, ".") {
+ return errors.Newf(spec.Pos(),
+ "package %q imported but not defined in %s",
+ info.ID, b.ImportPath)
+ }
+ return nil // TODO: check the builtin package exists here.
+ }
+
+ if v := x.index.importsByBuild[pkg]; v != nil {
+ return pkg.Err
+ }
+
+ if _, err := x.Build(pkg); err != nil {
+ return err
+ }
+
+ return nil
+}
diff --git a/internal/core/runtime/go.go b/internal/core/runtime/go.go
new file mode 100644
index 0000000..4b84b3f
--- /dev/null
+++ b/internal/core/runtime/go.go
@@ -0,0 +1,53 @@
+// Copyright 2020 CUE Authors
+//
+// 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 runtime
+
+import (
+ "reflect"
+
+ "cuelang.org/go/cue/ast"
+ "cuelang.org/go/internal/core/adt"
+)
+
+func (x *Runtime) StoreType(t reflect.Type, src ast.Expr, expr adt.Expr) {
+ if expr == nil {
+ x.index.StoreType(t, src)
+ } else {
+ x.index.StoreType(t, expr)
+ }
+}
+
+func (x *Runtime) LoadType(t reflect.Type) (src ast.Expr, expr adt.Expr, ok bool) {
+ v, ok := x.index.LoadType(t)
+ if ok {
+ switch x := v.(type) {
+ case ast.Expr:
+ return x, nil, true
+ case adt.Expr:
+ src, _ = x.Source().(ast.Expr)
+ return src, x, true
+ }
+ }
+ return nil, nil, false
+}
+
+func (x *index) StoreType(t reflect.Type, v interface{}) {
+ x.typeCache.Store(t, v)
+}
+
+func (x *index) LoadType(t reflect.Type) (v interface{}, ok bool) {
+ v, ok = x.typeCache.Load(t)
+ return v, ok
+}
diff --git a/internal/core/runtime/imports.go b/internal/core/runtime/imports.go
new file mode 100644
index 0000000..4f25c96
--- /dev/null
+++ b/internal/core/runtime/imports.go
@@ -0,0 +1,128 @@
+// Copyright 2020 CUE Authors
+//
+// 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 runtime
+
+import (
+ "path"
+ "sync"
+
+ "cuelang.org/go/cue/build"
+ "cuelang.org/go/cue/errors"
+ "cuelang.org/go/internal/core/adt"
+)
+
+type PackageFunc func(ctx adt.Runtime) (*adt.Vertex, errors.Error)
+
+func RegisterBuiltin(importPath string, f PackageFunc) {
+ sharedIndex.RegisterBuiltin(importPath, f)
+}
+
+func (x *index) RegisterBuiltin(importPath string, f PackageFunc) {
+ if x.builtins == nil {
+ x.builtins = map[string]PackageFunc{}
+ }
+ x.builtins[importPath] = f
+}
+
+var SharedRuntime = &Runtime{index: sharedIndex}
+
+func (x *Runtime) IsBuiltinPackage(path string) bool {
+ return x.index.isBuiltin(path)
+}
+
+// sharedIndex is used for indexing builtins and any other labels common to
+// all instances.
+var sharedIndex = newIndex()
+
+// index maps conversions from label names to internal codes.
+//
+// All instances belonging to the same package should share this index.
+type index struct {
+ // Change this to Instance at some point.
+ // From *structLit/*Vertex -> Instance
+ imports map[*adt.Vertex]*build.Instance
+ importsByPath map[string]*adt.Vertex
+ importsByBuild map[*build.Instance]*adt.Vertex
+ builtins map[string]PackageFunc
+
+ // mutex sync.Mutex
+ typeCache sync.Map // map[reflect.Type]evaluated
+
+}
+
+func newIndex() *index {
+ i := &index{
+ imports: map[*adt.Vertex]*build.Instance{},
+ importsByPath: map[string]*adt.Vertex{},
+ importsByBuild: map[*build.Instance]*adt.Vertex{},
+ }
+ return i
+}
+
+func (x *index) isBuiltin(id string) bool {
+ if x == nil || x.builtins == nil {
+ return false
+ }
+ _, ok := x.builtins[id]
+ return ok
+}
+
+func (r *Runtime) AddInst(path string, key *adt.Vertex, p *build.Instance) {
+ x := r.index
+ if key == nil {
+ panic("key must not be nil")
+ }
+ x.imports[key] = p
+ x.importsByBuild[p] = key
+ if path != "" {
+ x.importsByPath[path] = key
+ }
+}
+
+func (r *Runtime) GetInstanceFromNode(key *adt.Vertex) *build.Instance {
+ return r.index.imports[key]
+}
+
+func (r *Runtime) GetNodeFromInstance(key *build.Instance) *adt.Vertex {
+ return r.index.importsByBuild[key]
+}
+
+func (r *Runtime) LoadImport(importPath string) (*adt.Vertex, errors.Error) {
+ x := r.index
+
+ key := x.importsByPath[importPath]
+ if key != nil {
+ return key, nil
+ }
+
+ if x.builtins != nil {
+ if f := x.builtins[importPath]; f != nil {
+ p, err := f(r)
+ if err != nil {
+ return adt.ToVertex(&adt.Bottom{Err: err}), nil
+ }
+ inst := &build.Instance{
+ ImportPath: importPath,
+ PkgName: path.Base(importPath),
+ }
+ x.imports[p] = inst
+ x.importsByPath[importPath] = p
+ x.importsByBuild[inst] = p
+ return p, nil
+ }
+ }
+
+ return key, nil
+}
diff --git a/internal/core/runtime/index.go b/internal/core/runtime/index.go
index a8e381c..bf5867c 100644
--- a/internal/core/runtime/index.go
+++ b/internal/core/runtime/index.go
@@ -15,122 +15,30 @@
package runtime
import (
- "reflect"
"sync"
- "cuelang.org/go/cue/ast"
"cuelang.org/go/internal"
"cuelang.org/go/internal/core/adt"
)
-// Index maps conversions from label names to internal codes.
-//
-// All instances belonging to the same package should share this Index.
-//
-// INDEX IS A TRANSITIONAL TYPE TO BRIDGE THE OLD AND NEW
-// IMPLEMENTATIONS. USE RUNTIME.
-type Index struct {
- labelMap map[string]int64
- labels []string
-
- // Change this to Instance at some point.
- // From *structLit/*Vertex -> Instance
- imports map[interface{}]interface{}
- importsByPath map[string]interface{}
- // imports map[string]*adt.Vertex
-
- offset int64
- parent *Index
-
- // mutex sync.Mutex
- typeCache sync.Map // map[reflect.Type]evaluated
+func (r *Runtime) IndexToString(i int64) string {
+ return r.index.IndexToString(i)
}
-// SharedIndex is used for indexing builtins and any other labels common to
-// all instances.
-var SharedIndex = newSharedIndex()
-
-var SharedIndexNew = newSharedIndex()
-
-var SharedRuntimeNew = &Runtime{index: SharedIndexNew}
-
-func newSharedIndex() *Index {
- i := &Index{
- labelMap: map[string]int64{"": 0},
- labels: []string{""},
- imports: map[interface{}]interface{}{},
- importsByPath: map[string]interface{}{},
- }
- return i
+func (r *Runtime) StringToIndex(s string) int64 {
+ return getKey(s)
}
-// NewIndex creates a new index.
-func NewIndex(parent *Index) *Index {
- i := &Index{
- labelMap: map[string]int64{},
- imports: map[interface{}]interface{}{},
- importsByPath: map[string]interface{}{},
- offset: int64(len(parent.labels)) + parent.offset,
- parent: parent,
- }
- return i
+func (r *Runtime) LabelStr(l adt.Feature) string {
+ return l.IdentString(r)
}
-func (x *Index) IndexToString(i int64) string {
- for ; i < x.offset; x = x.parent {
- }
- return x.labels[i-x.offset]
+func (r *Runtime) StrLabel(str string) adt.Feature {
+ return r.Label(str, false)
}
-func (x *Index) StringToIndex(s string) int64 {
- for p := x; p != nil; p = p.parent {
- if f, ok := p.labelMap[s]; ok {
- return int64(f)
- }
- }
- index := int64(len(x.labelMap)) + x.offset
- x.labelMap[s] = index
- x.labels = append(x.labels, s)
- return int64(index)
-}
-
-func (x *Index) HasLabel(s string) (ok bool) {
- for c := x; c != nil; c = c.parent {
- _, ok = c.labelMap[s]
- if ok {
- break
- }
- }
- return ok
-}
-
-func (x *Index) StoreType(t reflect.Type, v interface{}) {
- x.typeCache.Store(t, v)
-}
-
-func (x *Index) LoadType(t reflect.Type) (v interface{}, ok bool) {
- v, ok = x.typeCache.Load(t)
- return v, ok
-}
-
-func (x *Index) StrLabel(str string) adt.Feature {
- return x.Label(str, false)
-}
-
-func (x *Index) NodeLabel(n ast.Node) (f adt.Feature, ok bool) {
- switch label := n.(type) {
- case *ast.BasicLit:
- name, _, err := ast.LabelName(label)
- return x.Label(name, false), err == nil
- case *ast.Ident:
- name, err := ast.ParseIdent(label)
- return x.Label(name, true), err == nil
- }
- return 0, false
-}
-
-func (x *Index) Label(s string, isIdent bool) adt.Feature {
- index := x.StringToIndex(s)
+func (r *Runtime) Label(s string, isIdent bool) adt.Feature {
+ index := r.StringToIndex(s)
typ := adt.StringLabel
if isIdent {
switch {
@@ -146,32 +54,39 @@
return f
}
-func (idx *Index) LabelStr(l adt.Feature) string {
- return l.IdentString(idx)
+// TODO: move to Runtime as fields.
+var (
+ labelMap = map[string]int{}
+ labels = make([]string, 0, 1000)
+ mutex sync.RWMutex
+)
+
+func init() {
+ getKey("")
}
-func (x *Index) AddInst(path string, key, p interface{}) {
- if key == nil {
- panic("key must not be nil")
+func getKey(s string) int64 {
+ mutex.RLock()
+ p, ok := labelMap[s]
+ mutex.RUnlock()
+ if ok {
+ return int64(p)
}
- x.imports[key] = p
- if path != "" {
- x.importsByPath[path] = key
+ mutex.Lock()
+ defer mutex.Unlock()
+ p, ok = labelMap[s]
+ if ok {
+ return int64(p)
}
+ p = len(labels)
+ labels = append(labels, s)
+ labelMap[s] = p
+ return int64(p)
}
-func (x *Index) GetImportFromNode(key interface{}) interface{} {
- imp := x.imports[key]
- if imp == nil && x.parent != nil {
- return x.parent.GetImportFromNode(key)
- }
- return imp
-}
-
-func (x *Index) GetImportFromPath(id string) interface{} {
- key := x.importsByPath[id]
- if key == nil && x.parent != nil {
- return x.parent.GetImportFromPath(id)
- }
- return key
+func (x *index) IndexToString(i int64) string {
+ mutex.RLock()
+ s := labels[i]
+ mutex.RUnlock()
+ return s
}
diff --git a/internal/core/runtime/resolve.go b/internal/core/runtime/resolve.go
index 29f19e4..94188db 100644
--- a/internal/core/runtime/resolve.go
+++ b/internal/core/runtime/resolve.go
@@ -23,15 +23,9 @@
"cuelang.org/go/cue/errors"
)
-func lineStr(idx *Index, n ast.Node) string {
- return n.Pos().String()
-}
+func (r *Runtime) ResolveFiles(p *build.Instance) (errs errors.Error) {
+ idx := r.index
-func ResolveFiles(
- idx *Index,
- p *build.Instance,
- isBuiltin func(s string) bool,
-) (errs errors.Error) {
// Link top-level declarations. As top-level entries get unified, an entry
// may be linked to any top-level entry of any of the files.
allFields := map[string]ast.Node{}
@@ -45,18 +39,17 @@
}
}
for _, f := range p.Files {
- err := ResolveFile(idx, f, p, allFields, isBuiltin)
+ err := resolveFile(idx, f, p, allFields)
errs = errors.Append(errs, err)
}
return errs
}
-func ResolveFile(
- idx *Index,
+func resolveFile(
+ idx *index,
f *ast.File,
p *build.Instance,
allFields map[string]ast.Node,
- isBuiltin func(s string) bool,
) errors.Error {
unresolved := map[string][]*ast.Ident{}
for _, u := range f.Unresolved {
@@ -82,7 +75,7 @@
name := path.Base(id)
if imp := p.LookupImport(id); imp != nil {
name = imp.PkgName
- } else if !isBuiltin(id) {
+ } else if _, ok := idx.builtins[id]; !ok {
errs = errors.Append(errs,
nodeErrorf(spec, "package %q not found", id))
continue
@@ -162,3 +155,7 @@
// }
return errs
}
+
+func lineStr(idx *index, n ast.Node) string {
+ return n.Pos().String()
+}
diff --git a/internal/core/runtime/resolve_test.go b/internal/core/runtime/resolve_test.go
index 42ec1dd..9bc7240 100644
--- a/internal/core/runtime/resolve_test.go
+++ b/internal/core/runtime/resolve_test.go
@@ -33,8 +33,6 @@
Path: ast.NewString(importPath),
}
- isBuiltin := func(s string) bool { return false }
-
f := &ast.File{
Decls: []ast.Decl{
&ast.ImportDecl{Specs: []*ast.ImportSpec{spec1, spec2}},
@@ -50,12 +48,12 @@
Imports: []*ast.ImportSpec{spec1, spec2},
}
- err := ResolveFile(nil, f, &build.Instance{
+ err := resolveFile(nil, f, &build.Instance{
Imports: []*build.Instance{{
ImportPath: importPath,
PkgName: "foo",
}},
- }, map[string]ast.Node{}, isBuiltin)
+ }, map[string]ast.Node{})
if err != nil {
t.Errorf("exected no error, found %v", err)
diff --git a/internal/core/runtime/runtime.go b/internal/core/runtime/runtime.go
index 6361e6b..448dc30 100644
--- a/internal/core/runtime/runtime.go
+++ b/internal/core/runtime/runtime.go
@@ -14,124 +14,18 @@
package runtime
-import (
- "reflect"
- "strings"
-
- "cuelang.org/go/cue/ast"
- "cuelang.org/go/cue/ast/astutil"
- "cuelang.org/go/cue/build"
- "cuelang.org/go/cue/errors"
- "cuelang.org/go/internal/core/adt"
- "cuelang.org/go/internal/core/compile"
-)
-
// A Runtime maintains data structures for indexing and resuse for evaluation.
type Runtime struct {
- index *Index
+ index *index
// Data holds the legacy index strut. It is for transitional purposes only.
Data interface{}
}
-// New creates a new Runtime.
+// New creates a new Runtime. The builtins registered with RegisterBuiltin
+// are available for
func New() *Runtime {
return &Runtime{
- index: NewIndex(SharedIndexNew),
+ index: sharedIndex,
}
}
-
-func NewWithIndex(x *Index) *Runtime {
- return &Runtime{index: x}
-}
-
-func (x *Runtime) IndexToString(i int64) string {
- return x.index.IndexToString(i)
-}
-
-func (x *Runtime) StringToIndex(s string) int64 {
- return x.index.StringToIndex(s)
-}
-
-func (x *Runtime) Build(b *build.Instance) (v *adt.Vertex, errs errors.Error) {
- if s := b.ImportPath; s != "" {
- // Use cached result, if available.
- if v, err := x.LoadImport(s); v != nil || err != nil {
- return v, err
- }
- // Cache the result if any.
- defer func() {
- if errs == nil && v != nil {
- x.index.AddInst(b.ImportPath, v, b)
- }
- }()
- }
-
- // Build transitive dependencies.
- for _, file := range b.Files {
- file.VisitImports(func(d *ast.ImportDecl) {
- for _, s := range d.Specs {
- errs = errors.Append(errs, x.buildSpec(b, s))
- }
- })
- }
-
- if errs != nil {
- return nil, errs
- }
-
- return compile.Files(nil, x, b.ID(), b.Files...)
-}
-
-func (x *Runtime) buildSpec(b *build.Instance, spec *ast.ImportSpec) (errs errors.Error) {
- info, err := astutil.ParseImportSpec(spec)
- if err != nil {
- return errors.Promote(err, "invalid import path")
- }
-
- pkg := b.LookupImport(info.ID)
- if pkg == nil {
- if strings.Contains(info.ID, ".") {
- return errors.Newf(spec.Pos(),
- "package %q imported but not defined in %s",
- info.ID, b.ImportPath)
- }
- return nil // TODO: check the builtin package exists here.
- }
-
- if _, err := x.Build(pkg); err != nil {
- return err
- }
-
- return nil
-}
-
-func (x *Runtime) LoadImport(importPath string) (*adt.Vertex, errors.Error) {
- v := x.index.GetImportFromPath(importPath)
- if v == nil {
- return nil, nil
- }
- return v.(*adt.Vertex), nil
-}
-
-func (x *Runtime) StoreType(t reflect.Type, src ast.Expr, expr adt.Expr) {
- if expr == nil {
- x.index.StoreType(t, src)
- } else {
- x.index.StoreType(t, expr)
- }
-}
-
-func (x *Runtime) LoadType(t reflect.Type) (src ast.Expr, expr adt.Expr, ok bool) {
- v, ok := x.index.LoadType(t)
- if ok {
- switch x := v.(type) {
- case ast.Expr:
- return x, nil, true
- case adt.Expr:
- src, _ = x.Source().(ast.Expr)
- return src, x, true
- }
- }
- return nil, nil, false
-}
