2015-04-23 00:54:31 +02:00
|
|
|
// Copyright (C) 2015 The Syncthing Authors.
|
|
|
|
//
|
|
|
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
|
|
|
// License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
|
|
|
// You can obtain one at http://mozilla.org/MPL/2.0/.
|
|
|
|
|
|
|
|
package sync
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"path/filepath"
|
|
|
|
"runtime"
|
2016-10-18 22:00:01 +02:00
|
|
|
"strconv"
|
2015-04-23 12:29:23 +02:00
|
|
|
"strings"
|
2015-04-23 00:54:31 +02:00
|
|
|
"sync"
|
2015-04-23 12:29:23 +02:00
|
|
|
"sync/atomic"
|
2015-04-23 00:54:31 +02:00
|
|
|
"time"
|
2016-11-05 03:24:53 +01:00
|
|
|
|
|
|
|
"github.com/sasha-s/go-deadlock"
|
2015-04-23 00:54:31 +02:00
|
|
|
)
|
|
|
|
|
|
|
|
type Mutex interface {
|
|
|
|
Lock()
|
|
|
|
Unlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
type RWMutex interface {
|
|
|
|
Mutex
|
|
|
|
RLock()
|
|
|
|
RUnlock()
|
|
|
|
}
|
|
|
|
|
|
|
|
type WaitGroup interface {
|
|
|
|
Add(int)
|
|
|
|
Done()
|
|
|
|
Wait()
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewMutex() Mutex {
|
2016-11-05 03:24:53 +01:00
|
|
|
if useDeadlock {
|
2016-11-05 03:31:52 +01:00
|
|
|
return &deadlock.Mutex{}
|
2016-11-05 03:24:53 +01:00
|
|
|
}
|
2015-04-23 00:54:31 +02:00
|
|
|
if debug {
|
2016-11-03 22:33:33 +01:00
|
|
|
mutex := &loggedMutex{}
|
|
|
|
mutex.holder.Store(holder{})
|
|
|
|
return mutex
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
return &sync.Mutex{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewRWMutex() RWMutex {
|
2016-11-05 03:24:53 +01:00
|
|
|
if useDeadlock {
|
2016-11-05 03:31:52 +01:00
|
|
|
return &deadlock.RWMutex{}
|
2016-11-05 03:24:53 +01:00
|
|
|
}
|
2015-04-23 00:54:31 +02:00
|
|
|
if debug {
|
2016-11-03 22:33:33 +01:00
|
|
|
mutex := &loggedRWMutex{
|
|
|
|
readHolders: make(map[int][]holder),
|
|
|
|
unlockers: make(chan holder, 1024),
|
2015-04-23 12:29:23 +02:00
|
|
|
}
|
2016-11-03 22:33:33 +01:00
|
|
|
mutex.holder.Store(holder{})
|
|
|
|
return mutex
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
return &sync.RWMutex{}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewWaitGroup() WaitGroup {
|
|
|
|
if debug {
|
|
|
|
return &loggedWaitGroup{}
|
|
|
|
}
|
|
|
|
return &sync.WaitGroup{}
|
|
|
|
}
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
type holder struct {
|
|
|
|
at string
|
|
|
|
time time.Time
|
|
|
|
goid int
|
|
|
|
}
|
|
|
|
|
|
|
|
func (h holder) String() string {
|
|
|
|
if h.at == "" {
|
|
|
|
return "not held"
|
|
|
|
}
|
|
|
|
return fmt.Sprintf("at %s goid: %d for %s", h.at, h.goid, time.Now().Sub(h.time))
|
|
|
|
}
|
|
|
|
|
2015-04-23 00:54:31 +02:00
|
|
|
type loggedMutex struct {
|
|
|
|
sync.Mutex
|
2016-11-03 22:33:33 +01:00
|
|
|
holder atomic.Value
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *loggedMutex) Lock() {
|
|
|
|
m.Mutex.Lock()
|
2016-11-03 22:33:33 +01:00
|
|
|
m.holder.Store(getHolder())
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *loggedMutex) Unlock() {
|
2016-11-03 22:33:33 +01:00
|
|
|
currentHolder := m.holder.Load().(holder)
|
|
|
|
duration := time.Now().Sub(currentHolder.time)
|
2015-04-23 00:54:31 +02:00
|
|
|
if duration >= threshold {
|
2016-11-03 22:33:33 +01:00
|
|
|
l.Debugf("Mutex held for %v. Locked at %s unlocked at %s", duration, currentHolder.at, getHolder().at)
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
2016-11-03 22:33:33 +01:00
|
|
|
m.holder.Store(holder{})
|
2015-04-23 00:54:31 +02:00
|
|
|
m.Mutex.Unlock()
|
|
|
|
}
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
func (m *loggedMutex) Holders() string {
|
|
|
|
return m.holder.Load().(holder).String()
|
2016-10-18 22:00:01 +02:00
|
|
|
}
|
|
|
|
|
2015-04-23 00:54:31 +02:00
|
|
|
type loggedRWMutex struct {
|
|
|
|
sync.RWMutex
|
2016-11-03 22:33:33 +01:00
|
|
|
holder atomic.Value
|
2015-04-23 12:29:23 +02:00
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
readHolders map[int][]holder
|
|
|
|
readHoldersMut sync.Mutex
|
2015-04-23 12:29:23 +02:00
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
logUnlockers int32
|
|
|
|
unlockers chan holder
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
func (m *loggedRWMutex) Lock() {
|
|
|
|
start := time.Now()
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
atomic.StoreInt32(&m.logUnlockers, 1)
|
2015-04-23 00:54:31 +02:00
|
|
|
m.RWMutex.Lock()
|
2015-04-23 12:29:23 +02:00
|
|
|
m.logUnlockers = 0
|
2015-04-23 00:54:31 +02:00
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
holder := getHolder()
|
|
|
|
m.holder.Store(holder)
|
|
|
|
|
|
|
|
duration := holder.time.Sub(start)
|
2015-04-23 00:54:31 +02:00
|
|
|
|
|
|
|
if duration > threshold {
|
2016-11-03 22:33:33 +01:00
|
|
|
var unlockerStrings []string
|
|
|
|
loop:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case holder := <-m.unlockers:
|
|
|
|
unlockerStrings = append(unlockerStrings, holder.String())
|
|
|
|
default:
|
|
|
|
break loop
|
|
|
|
}
|
|
|
|
}
|
|
|
|
l.Debugf("RWMutex took %v to lock. Locked at %s. RUnlockers while locking:\n%s", duration, holder.at, strings.Join(unlockerStrings, "\n"))
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (m *loggedRWMutex) Unlock() {
|
2016-11-03 22:33:33 +01:00
|
|
|
currentHolder := m.holder.Load().(holder)
|
|
|
|
duration := time.Now().Sub(currentHolder.time)
|
2015-04-23 00:54:31 +02:00
|
|
|
if duration >= threshold {
|
2016-11-03 22:33:33 +01:00
|
|
|
l.Debugf("RWMutex held for %v. Locked at %s unlocked at %s", duration, currentHolder.at, getHolder().at)
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
2016-11-03 22:33:33 +01:00
|
|
|
m.holder.Store(holder{})
|
2015-04-23 00:54:31 +02:00
|
|
|
m.RWMutex.Unlock()
|
|
|
|
}
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
func (m *loggedRWMutex) RLock() {
|
|
|
|
m.RWMutex.RLock()
|
|
|
|
holder := getHolder()
|
|
|
|
m.readHoldersMut.Lock()
|
|
|
|
m.readHolders[holder.goid] = append(m.readHolders[holder.goid], holder)
|
|
|
|
m.readHoldersMut.Unlock()
|
|
|
|
}
|
|
|
|
|
2015-04-23 12:29:23 +02:00
|
|
|
func (m *loggedRWMutex) RUnlock() {
|
2016-11-03 22:33:33 +01:00
|
|
|
id := goid()
|
|
|
|
m.readHoldersMut.Lock()
|
|
|
|
current := m.readHolders[id]
|
|
|
|
if len(current) > 0 {
|
|
|
|
m.readHolders[id] = current[:len(current)-1]
|
|
|
|
}
|
|
|
|
m.readHoldersMut.Unlock()
|
|
|
|
if atomic.LoadInt32(&m.logUnlockers) == 1 {
|
|
|
|
holder := getHolder()
|
|
|
|
select {
|
|
|
|
case m.unlockers <- holder:
|
|
|
|
default:
|
|
|
|
l.Debugf("Dropped holder %s as channel full", holder)
|
|
|
|
}
|
2015-04-23 12:29:23 +02:00
|
|
|
}
|
|
|
|
m.RWMutex.RUnlock()
|
|
|
|
}
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
func (m *loggedRWMutex) Holders() string {
|
|
|
|
output := m.holder.Load().(holder).String() + " (writer)"
|
|
|
|
m.readHoldersMut.Lock()
|
|
|
|
for _, holders := range m.readHolders {
|
|
|
|
for _, holder := range holders {
|
|
|
|
output += "\n" + holder.String() + " (reader)"
|
|
|
|
}
|
|
|
|
}
|
|
|
|
m.readHoldersMut.Unlock()
|
|
|
|
return output
|
2016-10-30 01:14:38 +02:00
|
|
|
}
|
|
|
|
|
2015-04-23 00:54:31 +02:00
|
|
|
type loggedWaitGroup struct {
|
|
|
|
sync.WaitGroup
|
|
|
|
}
|
|
|
|
|
2015-04-23 19:09:56 +02:00
|
|
|
func (wg *loggedWaitGroup) Wait() {
|
2015-04-23 00:54:31 +02:00
|
|
|
start := time.Now()
|
2015-04-23 19:09:56 +02:00
|
|
|
wg.WaitGroup.Wait()
|
2015-04-23 00:54:31 +02:00
|
|
|
duration := time.Now().Sub(start)
|
2015-04-23 19:09:56 +02:00
|
|
|
if duration >= threshold {
|
2016-11-03 22:33:33 +01:00
|
|
|
l.Debugf("WaitGroup took %v at %s", duration, getHolder())
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-11-03 22:33:33 +01:00
|
|
|
func getHolder() holder {
|
2015-04-23 19:09:56 +02:00
|
|
|
_, file, line, _ := runtime.Caller(2)
|
2015-04-23 00:54:31 +02:00
|
|
|
file = filepath.Join(filepath.Base(filepath.Dir(file)), filepath.Base(file))
|
2016-11-03 22:33:33 +01:00
|
|
|
return holder{
|
|
|
|
at: fmt.Sprintf("%s:%d", file, line),
|
|
|
|
goid: goid(),
|
|
|
|
time: time.Now(),
|
|
|
|
}
|
2015-04-23 00:54:31 +02:00
|
|
|
}
|
2016-10-18 22:00:01 +02:00
|
|
|
|
|
|
|
func goid() int {
|
|
|
|
var buf [64]byte
|
|
|
|
n := runtime.Stack(buf[:], false)
|
|
|
|
idField := strings.Fields(strings.TrimPrefix(string(buf[:n]), "goroutine "))[0]
|
|
|
|
id, err := strconv.Atoi(idField)
|
|
|
|
if err != nil {
|
|
|
|
return -1
|
|
|
|
}
|
|
|
|
return id
|
|
|
|
}
|