1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/sync/sync_windows.v

95 lines
2.2 KiB
V
Raw Normal View History

2019-06-23 05:21:30 +03:00
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
// Use of this source code is governed by an MIT license
// that can be found in the LICENSE file.
2019-06-22 22:53:22 +03:00
module sync
2019-07-24 18:36:20 +03:00
// Mutex HANDLE
type MHANDLE voidptr
2019-06-22 22:53:22 +03:00
2019-10-25 17:24:40 +03:00
//[init_with=new_mutex] // TODO: implement support for this struct attribute, and disallow Mutex{} from outside the sync.new_mutex() function.
pub struct Mutex {
2019-07-24 18:36:20 +03:00
mut:
mx MHANDLE // mutex handle
state MutexState // mutex state
cycle_wait i64 // waiting cycles (implemented only with atomic)
cycle_woken i64 // woken cycles ^
reader_sem u32 // reader semarphone
writer_sem u32 // writer semaphones
2019-06-22 22:53:22 +03:00
}
enum MutexState {
broken
waiting
released
abandoned
destroyed
}
2019-06-22 22:53:22 +03:00
2019-07-24 18:36:20 +03:00
const (
INFINITE = 0xffffffff
2019-07-24 18:36:20 +03:00
)
// Ref - https://docs.microsoft.com/en-us/windows/win32/api/synchapi/nf-synchapi-waitforsingleobject#return-value
const (
WAIT_ABANDONED = 0x00000080
WAIT_IO_COMPLETION = 0x000000C0
WAIT_OBJECT_0 = 0x00000000
WAIT_TIMEOUT = 0x00000102
WAIT_FAILED = 0xFFFFFFFF
2019-07-24 18:36:20 +03:00
)
2019-10-25 17:24:40 +03:00
pub fn new_mutex() Mutex {
sm := Mutex{}
unsafe {
mut m := sm
m.mx = C.CreateMutex(0, false, 0)
if isnil(m.mx) {
m.state = .broken // handle broken and mutex state are broken
return sm
}
return sm
}
}
2019-07-24 18:36:20 +03:00
pub fn (m mut Mutex) lock() {
// if mutex handle not initalized
if isnil(m.mx) {
m.mx = C.CreateMutex(0, false, 0)
if isnil(m.mx) {
m.state = .broken // handle broken and mutex state are broken
return
}
}
state := C.WaitForSingleObject(m.mx, INFINITE) // infinite wait
2019-10-30 17:29:05 +03:00
/* TODO fix match/enum combo
m.state = match state {
2019-10-30 16:43:40 +03:00
WAIT_ABANDONED { .abandoned }
WAIT_OBJECT_0 { .waiting }
else { .broken }
}
2019-10-30 17:29:05 +03:00
*/
mut s := MutexState.broken
if state == WAIT_ABANDONED { s = .abandoned }
else if state == WAIT_OBJECT_0 { s = .waiting }
m.state = s
2019-06-22 22:53:22 +03:00
}
2019-07-24 18:36:20 +03:00
pub fn (m mut Mutex) unlock() {
if m.state == .waiting {
if C.ReleaseMutex(m.mx) != 0 {
m.state = .broken
return
}
}
m.state = .released
}
2019-07-24 18:36:20 +03:00
pub fn (m mut Mutex) destroy() {
if m.state == .waiting {
m.unlock() // unlock mutex before destroying
}
C.CloseHandle(m.mx) // destroy mutex
m.state = .destroyed // setting up reference to invalid state
}