Source file src/pkg/cmd/go/internal/sumweb/cache.go

     1	// Copyright 2018 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	// Parallel cache.
     6	// This file is copied from cmd/go/internal/par.
     7	
     8	package sumweb
     9	
    10	import (
    11		"sync"
    12		"sync/atomic"
    13	)
    14	
    15	// parCache runs an action once per key and caches the result.
    16	type parCache struct {
    17		m sync.Map
    18	}
    19	
    20	type cacheEntry struct {
    21		done   uint32
    22		mu     sync.Mutex
    23		result interface{}
    24	}
    25	
    26	// Do calls the function f if and only if Do is being called for the first time with this key.
    27	// No call to Do with a given key returns until the one call to f returns.
    28	// Do returns the value returned by the one call to f.
    29	func (c *parCache) Do(key interface{}, f func() interface{}) interface{} {
    30		entryIface, ok := c.m.Load(key)
    31		if !ok {
    32			entryIface, _ = c.m.LoadOrStore(key, new(cacheEntry))
    33		}
    34		e := entryIface.(*cacheEntry)
    35		if atomic.LoadUint32(&e.done) == 0 {
    36			e.mu.Lock()
    37			if atomic.LoadUint32(&e.done) == 0 {
    38				e.result = f()
    39				atomic.StoreUint32(&e.done, 1)
    40			}
    41			e.mu.Unlock()
    42		}
    43		return e.result
    44	}
    45	
    46	// Get returns the cached result associated with key.
    47	// It returns nil if there is no such result.
    48	// If the result for key is being computed, Get does not wait for the computation to finish.
    49	func (c *parCache) Get(key interface{}) interface{} {
    50		entryIface, ok := c.m.Load(key)
    51		if !ok {
    52			return nil
    53		}
    54		e := entryIface.(*cacheEntry)
    55		if atomic.LoadUint32(&e.done) == 0 {
    56			return nil
    57		}
    58		return e.result
    59	}
    60	

View as plain text