#include "../../cmd/ld/textflag.h"
static struct {
- Lock l;
- byte pad[CacheLineSize-sizeof(Lock)];
+ Mutex l;
+ byte pad[CacheLineSize-sizeof(Mutex)];
} locktab[57];
#define LOCK(addr) (&locktab[((uintptr)(addr)>>3)%nelem(locktab)].l)
g->m->ncgocall++;
/*
- * Lock g to m to ensure we stay on the same stack if we do a
+ * Mutex g to m to ensure we stay on the same stack if we do a
* cgo callback. Add entry to defer stack in case of panic.
*/
runtime·lockOSThread();
t0 = cputicks()
}
- golock(&c.lock)
+ lock(&c.lock)
if c.closed != 0 {
- gounlock(&c.lock)
+ unlock(&c.lock)
panic("send on closed channel")
}
if raceenabled {
racesync(c, sg)
}
- gounlock(&c.lock)
+ unlock(&c.lock)
recvg := sg.g
recvg.param = unsafe.Pointer(sg)
}
if !block {
- gounlock(&c.lock)
+ unlock(&c.lock)
return false
}
var t1 int64
for c.qcount >= c.dataqsiz {
if !block {
- gounlock(&c.lock)
+ unlock(&c.lock)
return false
}
gp := getg()
t1 = int64(mysg.releasetime)
}
releaseSudog(mysg)
- golock(&c.lock)
+ lock(&c.lock)
if c.closed != 0 {
- gounlock(&c.lock)
+ unlock(&c.lock)
panic("send on closed channel")
}
}
sg := c.recvq.dequeue()
if sg != nil {
recvg := sg.g
- gounlock(&c.lock)
+ unlock(&c.lock)
if sg.releasetime != 0 {
*(*int64)(unsafe.Pointer(&sg.releasetime)) = cputicks()
}
goready(recvg)
} else {
- gounlock(&c.lock)
+ unlock(&c.lock)
}
if t1 > 0 {
blockevent(t1-t0, 2)
uintgo recvx; // receive index
WaitQ recvq; // list of recv waiters
WaitQ sendq; // list of send waiters
- Lock lock;
+ Mutex lock;
};
// Buffer follows Hchan immediately in memory.
bool eod_sent; // special end-of-data record sent; => flushing
};
-static Lock lk;
+static Mutex lk;
static Profile *prof;
static void tick(uintptr*, int32);
var F64toint = f64toint
func entersyscall()
-func golockedOSThread() bool
+func lockedOSThread() bool
func stackguard() (sp, limit uintptr)
var Entersyscall = entersyscall
var Exitsyscall = exitsyscall
-var LockedOSThread = golockedOSThread
+var LockedOSThread = lockedOSThread
var Stackguard = stackguard
type LFNode struct {
)
var (
- ifaceLock lock // lock for accessing hash
+ ifaceLock mutex // lock for accessing hash
hash [hashSize]*itab
)
var locked int
for locked = 0; locked < 2; locked++ {
if locked != 0 {
- golock(&ifaceLock)
+ lock(&ifaceLock)
}
for m = (*itab)(atomicloadp(unsafe.Pointer(&hash[h]))); m != nil; m = m.link {
if m.inter == inter && m._type == typ {
}
}
if locked != 0 {
- gounlock(&ifaceLock)
+ unlock(&ifaceLock)
}
return m
}
// didn't find method
if !canfail {
if locked != 0 {
- gounlock(&ifaceLock)
+ unlock(&ifaceLock)
}
panic(&TypeAssertionError{"", *typ._string, *inter.typ._string, *iname})
}
}
m.link = hash[h]
atomicstorep(unsafe.Pointer(&hash[h]), unsafe.Pointer(m))
- gounlock(&ifaceLock)
+ unlock(&ifaceLock)
if m.bad != 0 {
return nil
}
#include "../../cmd/ld/textflag.h"
extern Itab* runtime·hash[1009];
-extern Lock runtime·ifaceLock;
+extern Mutex runtime·ifaceLock;
// TODO: delete this when no longer used (ifaceE2I2 is all that's left)
static Itab*
// Note that there can be spinning threads during all states - they do not
// affect mutex's state.
void
-runtime·lock(Lock *l)
+runtime·lock(Mutex *l)
{
uint32 i, v, wait, spin;
}
void
-runtime·unlock(Lock *l)
+runtime·unlock(Mutex *l)
{
uint32 v;
};
void
-runtime·lock(Lock *l)
+runtime·lock(Mutex *l)
{
uintptr v;
uint32 i, spin;
}
void
-runtime·unlock(Lock *l)
+runtime·unlock(Mutex *l)
{
uintptr v;
M *mp;
static struct
{
- Lock lock;
+ Mutex lock;
byte* pos;
byte* end;
} persistent;
return
}
if gcpercent == gcpercentUnknown {
- golock(&mheap_.lock)
+ lock(&mheap_.lock)
if gcpercent == gcpercentUnknown {
gcpercent = readgogc()
}
- gounlock(&mheap_.lock)
+ unlock(&mheap_.lock)
}
if gcpercent < 0 {
return
uint64 nfree; // number of frees
// Statistics about malloc heap.
- // protected by mheap.Lock
+ // protected by mheap.lock
uint64 heap_alloc; // bytes allocated and still in use
uint64 heap_sys; // bytes obtained from system
uint64 heap_idle; // bytes in idle spans
int64 unusedsince; // First time spotted by GC in MSpanFree state
uintptr npreleased; // number of pages released to the OS
byte *limit; // end of data in span
- Lock specialLock; // guards specials list
+ Mutex specialLock; // guards specials list
Special *specials; // linked list of special records sorted by offset.
};
// Central list of free objects of a given size.
struct MCentral
{
- Lock lock;
+ Mutex lock;
int32 sizeclass;
MSpan nonempty; // list of spans with a free object
MSpan empty; // list of spans with no free objects (or cached in an MCache)
// but all the other global data is here too.
struct MHeap
{
- Lock lock;
+ Mutex lock;
MSpan free[MaxMHeapList]; // free lists of given length
MSpan freelarge; // free lists length >= MaxMHeapList
MSpan busy[MaxMHeapList]; // busy lists of large objects of given length
// central free lists for small size classes.
// the padding makes sure that the MCentrals are
- // spaced CacheLineSize bytes apart, so that each MCentral.Lock
+ // spaced CacheLineSize bytes apart, so that each MCentral.lock
// gets its own cache line.
struct {
MCentral mcentral;
FixAlloc cachealloc; // allocator for MCache*
FixAlloc specialfinalizeralloc; // allocator for SpecialFinalizer*
FixAlloc specialprofilealloc; // allocator for SpecialProfile*
- Lock speciallock; // lock for sepcial record allocators.
+ Mutex speciallock; // lock for sepcial record allocators.
// Malloc stats.
uint64 largefree; // bytes freed for large objects (>MaxSmallSize)
extern byte runtime·end[];
static byte *bloc = { runtime·end };
-static Lock memlock;
+static Mutex memlock;
enum
{
extern byte runtime·gcdata[];
extern byte runtime·gcbss[];
-static Lock finlock; // protects the following variables
+static Mutex finlock; // protects the following variables
static FinBlock *finq; // list of finalizers that are to be executed
static FinBlock *finc; // cache of free blocks
static FinBlock *allfin; // list of all blocks
BitVector runtime·gcdatamask;
BitVector runtime·gcbssmask;
-static Lock gclock;
+static Mutex gclock;
static void runfinq(void);
static void bgsweep(void);
void
runtime·unrollgcprog_m(void)
{
- static Lock lock;
+ static Mutex lock;
Type *typ;
byte *mask, *prog;
uintptr pos;
// Patterned after tcmalloc's algorithms; shorter code.
// NOTE(rsc): Everything here could use cas if contention became an issue.
-var proflock lock
+var proflock mutex
// All memory allocations are local and do not escape outside of the profiler.
// The profiler is forbidden from referring to garbage-collected memory.
// the testing package's -test.memprofile flag instead
// of calling MemProfile directly.
func MemProfile(p []MemProfileRecord, inuseZero bool) (n int, ok bool) {
- golock(&proflock)
+ lock(&proflock)
clear := true
for b := mbuckets; b != nil; b = b.allnext {
if inuseZero || b.data.mp.alloc_bytes != b.data.mp.free_bytes {
}
}
}
- gounlock(&proflock)
+ unlock(&proflock)
return
}
// the testing package's -test.blockprofile flag instead
// of calling BlockProfile directly.
func BlockProfile(p []BlockProfileRecord) (n int, ok bool) {
- golock(&proflock)
+ lock(&proflock)
for b := bbuckets; b != nil; b = b.allnext {
n++
}
idx++
}
}
- gounlock(&proflock)
+ unlock(&proflock)
return
}
#include "type.h"
// NOTE(rsc): Everything here could use cas if contention became an issue.
-extern Lock runtime·proflock;
+extern Mutex runtime·proflock;
// All memory allocations are local and do not escape outside of the profiler.
// The profiler is forbidden from referring to garbage-collected memory.
// Tracing of alloc/free/gc.
-static Lock tracelock;
+static Mutex tracelock;
void
runtime·tracealloc(void *p, uintptr size, Type *type)
struct PollDesc
{
- PollDesc* link; // in pollcache, protected by pollcache.Lock
+ PollDesc* link; // in pollcache, protected by pollcache.lock
// The lock protects pollOpen, pollSetDeadline, pollUnblock and deadlineimpl operations.
// This fully covers seq, rt and wt variables. fd is constant throughout the PollDesc lifetime.
// pollReset, pollWait, pollWaitCanceled and runtime·netpollready (IO rediness notification)
// proceed w/o taking the lock. So closing, rg, rd, wg and wd are manipulated
// in a lock-free way by all operations.
- Lock lock; // protectes the following fields
+ Mutex lock; // protects the following fields
uintptr fd;
bool closing;
uintptr seq; // protects from stale timers and ready notifications
static struct
{
- Lock lock;
+ Mutex lock;
PollDesc* first;
// PollDesc objects must be type-stable,
// because we can get ready notification from epoll/kqueue
void
runtime·resetcpuprofiler(int32 hz)
{
- static Lock lock;
+ static Mutex lock;
void *timer, *thread;
int32 ms;
int64 due;
// Code related to defer, panic and recover.
uint32 runtime·panicking;
-static Lock paniclk;
+static Mutex paniclk;
// Each P holds pool for defers with arg sizes 8, 24, 40, 56 and 72 bytes.
// Memory block is 40 (24 for 32 bits) bytes larger due to Defer header.
// Let it print what it needs to print.
// Wait forever without chewing up cpu.
// It will exit when it's done.
- static Lock deadlock;
+ static Mutex deadlock;
runtime·lock(&deadlock);
runtime·lock(&deadlock);
}
#include "type.h"
#include "../../cmd/ld/textflag.h"
-//static Lock debuglock;
+//static Mutex debuglock;
static void vprintf(int8*, byte*);
typedef struct Sched Sched;
struct Sched {
- Lock lock;
+ Mutex lock;
uint64 goidgen;
int32 runqsize;
// Global cache of dead G's.
- Lock gflock;
+ Mutex gflock;
G* gfree;
int32 ngfree;
int32 runtime·ncpu;
static int32 newprocs;
-static Lock allglock; // the following vars are protected by this lock or by stoptheworld
+static Mutex allglock; // the following vars are protected by this lock or by stoptheworld
G** runtime·allg;
uintptr runtime·allglen;
static uintptr allgcap;
static void forcegchelper(void);
static struct
{
- Lock lock;
+ Mutex lock;
G* g;
FuncVal fv;
uint32 idle;
// Puts the current goroutine into a waiting state and unlocks the lock.
// The goroutine can be made runnable again by calling runtime·ready(gp).
void
-runtime·parkunlock(Lock *lock, String reason)
+runtime·parkunlock(Mutex *lock, String reason)
{
runtime·park(runtime·parkunlock_c, lock, reason);
}
}
static struct {
- Lock lock;
+ Mutex lock;
void (*fn)(uintptr*, int32);
int32 hz;
} prof;
// Puts the current goroutine into a waiting state and unlocks the lock.
// The goroutine can be made runnable again by calling goready(gp).
-func goparkunlock(lock *lock, reason string) {
+func goparkunlock(lock *mutex, reason string) {
gopark(unsafe.Pointer(&parkunlock_c), unsafe.Pointer(lock), reason)
}
return x;
}
-static Lock ticksLock;
+static Mutex ticksLock;
static int64 ticks;
int64
typedef struct G G;
typedef struct Gobuf Gobuf;
typedef struct SudoG SudoG;
-typedef struct Lock Lock;
+typedef struct Mutex Mutex;
typedef struct M M;
typedef struct P P;
typedef struct Note Note;
/*
* structures
*/
-struct Lock
+struct Mutex
{
// Futex-based impl treats it as uint32 key,
// while sema-based impl as M* waitm.
struct P
{
- Lock lock;
+ Mutex lock;
int32 id;
uint32 status; // one of Pidle/Prunning/...
void runtime·gosched_m(G*);
void runtime·schedtrace(bool);
void runtime·park(bool(*)(G*, void*), void*, String);
-void runtime·parkunlock(Lock*, String);
+void runtime·parkunlock(Mutex*, String);
void runtime·tsleep(int64, String);
M* runtime·newm(void);
void runtime·goexit(void);
* mutual exclusion locks. in the uncontended case,
* as fast as spin locks (just a few user-level instructions),
* but on the contention path they sleep in the kernel.
- * a zeroed Lock is unlocked (no need to initialize each lock).
+ * a zeroed Mutex is unlocked (no need to initialize each lock).
*/
-void runtime·lock(Lock*);
-void runtime·unlock(Lock*);
+void runtime·lock(Mutex*);
+void runtime·unlock(Mutex*);
/*
* sleep and wakeup on one-time events.
void runtime·futexwakeup(uint32*, uint32);
/*
- * Lock-free stack.
+ * Mutex-free stack.
* Initialize uint64 head to 0, compare with 0 to test for emptiness.
* The stack does not keep pointers to nodes,
* so they can be garbage collected if there are no other pointers to nodes.
// Asynchronous semaphore for sync.Mutex.
type semaRoot struct {
- lock
+ lock mutex
head *sudog
tail *sudog
nwait uint32 // Number of waiters. Read w/o the lock.
s.releasetime = -1
}
for {
- golock(&root.lock)
+ lock(&root.lock)
// Add ourselves to nwait to disable "easy case" in semrelease.
xadd(&root.nwait, 1)
// Check cansemacquire to avoid missed wakeup.
if cansemacquire(addr) {
xadd(&root.nwait, -1)
- gounlock(&root.lock)
+ unlock(&root.lock)
break
}
// Any semrelease after the cansemacquire knows we're waiting
}
// Harder case: search for a waiter and wake it.
- golock(&root.lock)
+ lock(&root.lock)
if atomicload(&root.nwait) == 0 {
// The count is already consumed by another goroutine,
// so no need to wake up another goroutine.
- gounlock(&root.lock)
+ unlock(&root.lock)
return
}
s := root.head
break
}
}
- gounlock(&root.lock)
+ unlock(&root.lock)
if s != nil {
if s.releasetime != 0 {
s.releasetime = cputicks()
// Synchronous semaphore for sync.Cond.
type syncSema struct {
- lock lock
+ lock mutex
head *sudog
tail *sudog
}
// Syncsemacquire waits for a pairing syncsemrelease on the same semaphore s.
func syncsemacquire(s *syncSema) {
- golock(&s.lock)
+ lock(&s.lock)
if s.head != nil && s.head.nrelease > 0 {
// Have pending release, consume it.
var wake *sudog
s.tail = nil
}
}
- gounlock(&s.lock)
+ unlock(&s.lock)
if wake != nil {
goready(wake.g)
}
// Syncsemrelease waits for n pairing syncsemacquire on the same semaphore s.
func syncsemrelease(s *syncSema, n uint32) {
- golock(&s.lock)
+ lock(&s.lock)
for n > 0 && s.head != nil && s.head.nrelease < 0 {
// Have pending acquire, satisfy it.
wake := s.head
s.tail = w
goparkunlock(&s.lock, "semarelease")
} else {
- gounlock(&s.lock)
+ unlock(&s.lock)
}
}
// order = log_2(size/FixedStack)
// There is a free list for each order.
static MSpan stackpool[NumStackOrders];
-static Lock stackpoolmu;
+static Mutex stackpoolmu;
// TODO: one lock per order?
void
// in panic.c
func gothrow(s string)
-func golock(x *lock)
-func gounlock(x *lock)
-
// Return the Go equivalent of the C Alg structure.
// TODO: at some point Go will hold the truth for the layout
// of runtime structures and C will be derived from it (if
func notewakeup(n *note)
func notesleep(n *note)
func noteclear(n *note)
+func lock(lk *mutex)
+func unlock(lk *mutex)
//go:noescape
func cas(ptr *uint32, old, new uint32) bool
// These invariants do not hold yet but will be established once we have
// finished converting runtime support code from C to Go.
-#pragma textflag NOSPLIT
-func golock(p *Lock) {
- runtime·lock(p);
-}
-#pragma textflag NOSPLIT
-func gounlock(p *Lock) {
- runtime·unlock(p);
-}
-
// entry point for testing
// TODO: mcall and run on M stack
func gostringW(str Slice) (s String) {
argsize += uintptrSize
}
- golock(&cbs.lock)
- defer gounlock(&cbs.lock)
+ lock(&cbs.lock)
+ defer unlock(&cbs.lock)
n := cbs.n
for i := 0; i < n; i++ {
}
var timers struct {
- lock lock
+ lock mutex
gp *g
created bool
sleeping bool
t.when = nanotime() + ns
t.f = goroutineReady
t.arg = getg()
- golock(&timers.lock)
+ lock(&timers.lock)
addtimerLocked(t)
goparkunlock(&timers.lock, "sleep")
}
}
func addtimer(t *timer) {
- golock(&timers.lock)
+ lock(&timers.lock)
addtimerLocked(t)
- gounlock(&timers.lock)
+ unlock(&timers.lock)
}
// Add a timer to the heap and start or kick the timer proc.
// Discard result, because t might be moving in the heap.
_ = t.i
- golock(&timers.lock)
+ lock(&timers.lock)
// t may not be registered anymore and may have
// a bogus i (typically 0, if generated by Go).
// Verify it before proceeding.
i := t.i
last := len(timers.t) - 1
if i < 0 || i > last || timers.t[i] != t {
- gounlock(&timers.lock)
+ unlock(&timers.lock)
return false
}
if i != last {
siftupTimer(i)
siftdownTimer(i)
}
- gounlock(&timers.lock)
+ unlock(&timers.lock)
return true
}
timers.gp = getg()
timers.gp.issystem = true
for {
- golock(&timers.lock)
+ lock(&timers.lock)
timers.sleeping = false
now := nanotime()
delta := int64(-1)
}
f := t.f
arg := t.arg
- gounlock(&timers.lock)
+ unlock(&timers.lock)
if raceenabled {
raceacquire(unsafe.Pointer(t))
}
f(arg)
- golock(&timers.lock)
+ lock(&timers.lock)
}
if delta < 0 {
// No timers left - put goroutine to sleep.
// At least one timer pending. Sleep until then.
timers.sleeping = true
noteclear(&timers.waitnote)
- gounlock(&timers.lock)
+ unlock(&timers.lock)
notetsleepg(&timers.waitnote, delta)
}
}