iframe-proxy | Sunbelt Computer Software

119 lines (105 loc) · 3.31 KB

// Copyright 2016 Google Inc. 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 grumpy
	"sync/atomic"
	argsCacheSize = 16
	argsCacheArgc = 6
type threadState struct {
	reprState    map[*Object]bool
	excValue     *BaseException
	excTraceback *Traceback
	// argsCache is a small, per-thread LIFO cache for arg lists. Entries
	// have a fixed capacity so calls to functions with larger parameter
	// lists will be allocated afresh each time. Args freed when the cache
	// is full are dropped. If the cache is empty then a new args slice
	// will be allocated.
	argsCache []Args
	// frameCache is a local cache of allocated frames almost ready for
	// reuse. The cache is maintained through the Frame `back` pointer as a
	// singly linked list.
	frameCache *Frame
func newThreadState() *threadState {
	return &threadState{argsCache: make([]Args, 0, argsCacheSize)}
// recursiveMutex implements a typical reentrant lock, similar to Python's
// RLock. Lock can be called multiple times for the same frame stack.
type recursiveMutex struct {
	mutex       sync.Mutex
	threadState *threadState
	count       int
func (m *recursiveMutex) Lock(f *Frame) {
	p := (*unsafe.Pointer)(unsafe.Pointer(&m.threadState))
	if (*threadState)(atomic.LoadPointer(p)) != f.threadState {
		// m.threadState != f.threadState implies m is not held by this
		// thread and therefore we won't deadlock acquiring the mutex.
		m.mutex.Lock()
		// m.threadState is now guaranteed to be empty (otherwise we
		// couldn't have acquired m.mutex) so store our own thread ID.
		atomic.StorePointer(p, unsafe.Pointer(f.threadState))
		m.count++
		m.count++
func (m *recursiveMutex) Unlock(f *Frame) {
	p := (*unsafe.Pointer)(unsafe.Pointer(&m.threadState))
	if (*threadState)(atomic.LoadPointer(p)) != f.threadState {
		logFatal("recursiveMutex.Unlock: frame did not match that passed to Lock")
	// Since we're unlocking, we must hold m.mutex, so this is safe.
	if m.count <= 0 {
		logFatal("recursiveMutex.Unlock: Unlock called too many times")
	if m.count == 0 {
		atomic.StorePointer(p, unsafe.Pointer(nil))
		m.mutex.Unlock()
// TryableMutex is a mutex-like object that also supports TryLock().
type TryableMutex struct {
	c chan bool
// NewTryableMutex returns a new TryableMutex.
func NewTryableMutex() *TryableMutex {
	m := &TryableMutex{make(chan bool, 1)}
	m.Unlock()
// Lock blocks until the mutex is available and then acquires a lock.
func (m *TryableMutex) Lock() {
// TryLock returns true and acquires a lock if the mutex is available, otherwise
// it returns false.
func (m *TryableMutex) TryLock() bool {
	case <-m.c:
		return true
		return false
// Unlock releases the mutex's lock.
func (m *TryableMutex) Unlock() {
	m.c <- true

Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

threading.go

Latest commit

History

threading.go

File metadata and controls