syncthing/lib/sync/sync.go

231 lines
4.5 KiB
Go
Raw Normal View History

2015-04-22 22:54:31 +00: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"
"strconv"
"strings"
2015-04-22 22:54:31 +00:00
"sync"
"sync/atomic"
2015-04-22 22:54:31 +00:00
"time"
"github.com/sasha-s/go-deadlock"
2015-04-22 22:54:31 +00:00
)
type Mutex interface {
Lock()
Unlock()
}
type RWMutex interface {
Mutex
RLock()
RUnlock()
}
type WaitGroup interface {
Add(int)
Done()
Wait()
}
func NewMutex() Mutex {
if useDeadlock {
2016-11-05 02:31:52 +00:00
return &deadlock.Mutex{}
}
2015-04-22 22:54:31 +00:00
if debug {
2016-11-03 21:33:33 +00:00
mutex := &loggedMutex{}
mutex.holder.Store(holder{})
return mutex
2015-04-22 22:54:31 +00:00
}
return &sync.Mutex{}
}
func NewRWMutex() RWMutex {
if useDeadlock {
2016-11-05 02:31:52 +00:00
return &deadlock.RWMutex{}
}
2015-04-22 22:54:31 +00:00
if debug {
2016-11-03 21:33:33 +00:00
mutex := &loggedRWMutex{
readHolders: make(map[int][]holder),
unlockers: make(chan holder, 1024),
}
2016-11-03 21:33:33 +00:00
mutex.holder.Store(holder{})
return mutex
2015-04-22 22:54:31 +00:00
}
return &sync.RWMutex{}
}
func NewWaitGroup() WaitGroup {
if debug {
return &loggedWaitGroup{}
}
return &sync.WaitGroup{}
}
2016-11-03 21:33:33 +00: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-22 22:54:31 +00:00
type loggedMutex struct {
sync.Mutex
2016-11-03 21:33:33 +00:00
start time.Time
holder atomic.Value
2015-04-22 22:54:31 +00:00
}
func (m *loggedMutex) Lock() {
m.Mutex.Lock()
2016-11-03 21:33:33 +00:00
m.holder.Store(getHolder())
2015-04-22 22:54:31 +00:00
}
func (m *loggedMutex) Unlock() {
2016-11-03 21:33:33 +00:00
currentHolder := m.holder.Load().(holder)
duration := time.Now().Sub(currentHolder.time)
2015-04-22 22:54:31 +00:00
if duration >= threshold {
2016-11-03 21:33:33 +00:00
l.Debugf("Mutex held for %v. Locked at %s unlocked at %s", duration, currentHolder.at, getHolder().at)
2015-04-22 22:54:31 +00:00
}
2016-11-03 21:33:33 +00:00
m.holder.Store(holder{})
2015-04-22 22:54:31 +00:00
m.Mutex.Unlock()
}
2016-11-03 21:33:33 +00:00
func (m *loggedMutex) Holders() string {
return m.holder.Load().(holder).String()
}
2015-04-22 22:54:31 +00:00
type loggedRWMutex struct {
sync.RWMutex
2016-11-03 21:33:33 +00:00
holder atomic.Value
2016-11-03 21:33:33 +00:00
readHolders map[int][]holder
readHoldersMut sync.Mutex
2016-11-03 21:33:33 +00:00
logUnlockers int32
unlockers chan holder
2015-04-22 22:54:31 +00:00
}
func (m *loggedRWMutex) Lock() {
start := time.Now()
2016-11-03 21:33:33 +00:00
atomic.StoreInt32(&m.logUnlockers, 1)
2015-04-22 22:54:31 +00:00
m.RWMutex.Lock()
m.logUnlockers = 0
2015-04-22 22:54:31 +00:00
2016-11-03 21:33:33 +00:00
holder := getHolder()
m.holder.Store(holder)
duration := holder.time.Sub(start)
2015-04-22 22:54:31 +00:00
if duration > threshold {
2016-11-03 21:33:33 +00: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-22 22:54:31 +00:00
}
}
func (m *loggedRWMutex) Unlock() {
2016-11-03 21:33:33 +00:00
currentHolder := m.holder.Load().(holder)
duration := time.Now().Sub(currentHolder.time)
2015-04-22 22:54:31 +00:00
if duration >= threshold {
2016-11-03 21:33:33 +00:00
l.Debugf("RWMutex held for %v. Locked at %s unlocked at %s", duration, currentHolder.at, getHolder().at)
2015-04-22 22:54:31 +00:00
}
2016-11-03 21:33:33 +00:00
m.holder.Store(holder{})
2015-04-22 22:54:31 +00:00
m.RWMutex.Unlock()
}
2016-11-03 21:33:33 +00: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()
}
func (m *loggedRWMutex) RUnlock() {
2016-11-03 21:33:33 +00: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)
}
}
m.RWMutex.RUnlock()
}
2016-11-03 21:33:33 +00: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
}
2015-04-22 22:54:31 +00:00
type loggedWaitGroup struct {
sync.WaitGroup
}
func (wg *loggedWaitGroup) Wait() {
2015-04-22 22:54:31 +00:00
start := time.Now()
wg.WaitGroup.Wait()
2015-04-22 22:54:31 +00:00
duration := time.Now().Sub(start)
if duration >= threshold {
2016-11-03 21:33:33 +00:00
l.Debugf("WaitGroup took %v at %s", duration, getHolder())
2015-04-22 22:54:31 +00:00
}
}
2016-11-03 21:33:33 +00:00
func getHolder() holder {
_, file, line, _ := runtime.Caller(2)
2015-04-22 22:54:31 +00:00
file = filepath.Join(filepath.Base(filepath.Dir(file)), filepath.Base(file))
2016-11-03 21:33:33 +00:00
return holder{
at: fmt.Sprintf("%s:%d", file, line),
goid: goid(),
time: time.Now(),
}
2015-04-22 22:54:31 +00: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
}