func (s *Semaphore) AcquireTimeout(timeout time.Duration) bool {
done := make(chan bool, 1)
// Gate used to communicate between the threads and decide what the result
// is. If the main thread decides, we have timed out, otherwise we succeed.
decided := new(int32)
go func() {
s.Acquire()
if atomic.SwapInt32(decided, 1) == 0 {
done <- true
} else {
// If we already decided the result, and this thread did not win
s.Release()
}
}()
select {
case <-done:
return true
case <-time.NewTimer(timeout).C:
if atomic.SwapInt32(decided, 1) == 1 {
// The other thread already decided the result
return true
}
return false
}
}
func watchUpdate(kv kvdb.Kvdb, data *watchData) error {
var err error
var kvp *kvdb.KVPair
data.reader, data.writer = 0, 0
atomic.AddInt32(&data.writer, 1)
// whichKey = 1 : key
// whichKey = 0 : otherKey
atomic.SwapInt32(&data.whichKey, 1)
data.action = kvdb.KVCreate
fmt.Printf("-")
kvp, err = kv.Create(data.key, []byte("bar"), 0)
for i := 0; i < data.iterations && err == nil; i++ {
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
data.action = kvdb.KVSet
kvp, err = kv.Put(data.key, []byte("bar"), 0)
data.updateIndex = kvp.KVDBIndex
assert.NoError(data.t, err, "Unexpected error in Put")
}
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
// Delete key
data.action = kvdb.KVDelete
kv.Delete(data.key)
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
atomic.SwapInt32(&data.whichKey, 0)
data.action = kvdb.KVDelete
// Delete otherKey
kv.Delete(data.otherKey)
fmt.Printf("-")
for data.writer != data.reader {
time.Sleep(time.Millisecond * 100)
}
atomic.AddInt32(&data.writer, 1)
atomic.SwapInt32(&data.whichKey, 1)
data.action = kvdb.KVCreate
_, err = kv.Create(data.key, []byte(data.stop), 0)
return err
}
func (b *Buffer) finishPut() {
atomic.AddInt32(&b.ring.wpos, 1)
atomic.CompareAndSwapInt32(&b.ring.wpos, b.ring.size, 0)
atomic.SwapInt32(&b.readonly, 1)
b.lock.Unlock()
}
func (this *AtomicBoolean) Set(val bool) bool {
var b int32 = 0
if val {
b = 1
}
return atomic.SwapInt32((*int32)(this), b) != 0
}
func (mailbox *endpointWriterMailbox) processMessages() {
//we are about to start processing messages, we can safely reset the message flag of the mailbox
atomic.StoreInt32(&mailbox.hasMoreMessages, mailboxHasNoMessages)
batchSize := mailbox.batchSize
done := false
for !done {
if sysMsg, ok := mailbox.systemMailbox.Pop(); ok {
first := sysMsg.(actor.SystemMessage)
mailbox.systemInvoke(first)
} else if userMsg, ok := mailbox.userMailbox.PopMany(batchSize); ok {
mailbox.userInvoke(userMsg)
} else {
done = true
break
}
runtime.Gosched()
}
//set mailbox to idle
atomic.StoreInt32(&mailbox.schedulerStatus, mailboxIdle)
//check if there are still messages to process (sent after the message loop ended)
if atomic.SwapInt32(&mailbox.hasMoreMessages, mailboxHasNoMessages) == mailboxHasMoreMessages {
mailbox.schedule()
}
}
func (mailbox *unboundedMailbox) processMessages() {
//we are about to start processing messages, we can safely reset the message flag of the mailbox
atomic.StoreInt32(&mailbox.hasMoreMessages, mailboxHasNoMessages)
done := false
for !done {
//process x messages in sequence, then exit
for i := 0; i < mailbox.throughput; i++ {
if sysMsg, ok := mailbox.systemMailbox.Pop(); ok {
sys, _ := sysMsg.(SystemMessage)
mailbox.systemInvoke(sys)
} else if userMsg, ok := mailbox.userMailbox.Pop(); ok {
mailbox.userInvoke(userMsg)
} else {
done = true
break
}
}
runtime.Gosched()
}
//set mailbox to idle
atomic.StoreInt32(&mailbox.schedulerStatus, mailboxIdle)
//check if there are still messages to process (sent after the message loop ended)
if atomic.SwapInt32(&mailbox.hasMoreMessages, mailboxHasNoMessages) == mailboxHasMoreMessages {
mailbox.schedule()
}
}
// Implement kanzi.InputStream interface
func (this *CompressedInputStream) Close() error {
if atomic.SwapInt32(&this.closed, 1) == 1 {
return nil
}
if _, err := this.ibs.Close(); err != nil {
return err
}
// Release resources
this.maxIdx = 0
this.data = EMPTY_BYTE_SLICE
for i := range this.buffers {
this.buffers[i] = EMPTY_BYTE_SLICE
}
for _, c := range this.syncChan {
if c != nil {
close(c)
}
}
close(this.resChan)
return nil
}
func (this *CompressedOutputStream) Close() error {
if atomic.SwapInt32(&this.closed, 1) == 1 {
return nil
}
if this.curIdx > 0 {
if err := this.processBlock(); err != nil {
return err
}
this.curIdx = 0
}
// Write end block of size 0
this.obs.WriteBits(SMALL_BLOCK_MASK, 8)
if _, err := this.obs.Close(); err != nil {
return err
}
// Release resources
this.data = EMPTY_BYTE_SLICE
for i := range this.buffers {
this.buffers[i] = EMPTY_BYTE_SLICE
}
for _, c := range this.channels {
close(c)
}
return nil
}
func (pc *SocketClient) Close() {
pc.changes.Lock()
defer pc.changes.Unlock()
if atomic.SwapInt32(&pc.state, SocketClosed) != SocketClosed {
close(pc.writeQueue)
}
}
// functions for monitoring internals
func monitor(mon *mylib.Mmon, boss mylib.Boss) {
// just pick up first sender all the time, kiss
sender := boss.Senders[0]
ticker := time.Tick(1000 * time.Millisecond)
last := time.Now()
for {
select {
case <-ticker:
// log("debug", fmt.Sprintf("sending to %s..", sender.host))
curr_time := time.Now()
if curr_time.Unix() > last.Unix() {
send_mon_data(atomic.SwapInt32(&mon.Send, 0), atomic.SwapInt32(&mon.Rcv, 0), atomic.SwapInt32(&mon.Conn, 0), boss.Port, curr_time, sender)
last = curr_time
}
}
}
}
func (t *Terminal) Close() error {
if atomic.SwapInt32(&t.closed, 1) != 0 {
return nil
}
t.stopChan <- struct{}{}
t.wg.Wait()
return t.ExitRawMode()
}
func (c *Cache) monitor() {
tick := time.Tick(10 * time.Second)
start := time.Now()
for {
select {
case <-tick:
in := atomic.SwapInt32(&c.inCache, 0)
out := atomic.SwapInt32(&c.outCache, 0)
all := atomic.SwapInt32(&c.requestCount, 0)
now := time.Now()
delta := now.Sub(start).Nanoseconds()
speed := int64(all) * 1000000000 / int64(delta)
log.Printf("Speed %d. In: %d, Out: %d, All: %d\n", speed, in, out, all)
start = now
}
}
}
func (b *Buffer) lastDo() {
if b.index+1 == b.ring.size {
atomic.StoreInt32(&b.ring.rpos, 0)
} else {
atomic.StoreInt32(&b.ring.rpos, b.index+1)
}
atomic.SwapInt32(&b.readonly, 0)
}
func (b *AtomicBool) Swap(v bool) bool {
var n AtomicBool
if v {
n = TRUE
}
return atomic.SwapInt32((*int32)(unsafe.Pointer(b)), int32(n)) != int32(FALSE)
}
// Set sets the current node ID. If it is already set, the value must match.
func (n *NodeIDContainer) Set(ctx context.Context, val roachpb.NodeID) {
if val <= 0 {
log.Fatalf(ctx, "trying to set invalid NodeID: %d", val)
}
oldVal := atomic.SwapInt32(&n.nodeID, int32(val))
if oldVal == 0 {
log.Infof(ctx, "NodeID set to %d", val)
} else if oldVal != int32(val) {
log.Fatalf(ctx, "different NodeIDs set: %d, then %d", oldVal, val)
}
}
func (t *Terminal) Close() error {
if atomic.SwapInt32(&t.closed, 1) != 0 {
return nil
}
if closer, ok := t.cfg.Stdin.(io.Closer); ok {
closer.Close()
}
close(t.stopChan)
t.wg.Wait()
return t.ExitRawMode()
}
func (s *Server) Close() {
atomic.SwapInt32(s.closed, 1)
s.roomsMu.Lock()
for _, clients := range s.rooms {
for _, client := range clients {
atomic.StoreInt32(client.closed, 1)
client.Close()
}
}
s.roomsMu.Unlock()
}
func (i *Instance) Close() bool {
if atomic.SwapInt32(&i.closed, 1) != 0 {
return false
}
i.Lock()
for idx, fc := range i.slot {
fc.done()
i.slot[idx] = nil
}
i.Unlock()
return true
}
func (b *Buffer) nextPut() *Buffer {
atomic.AddInt32(&b.ring.wpos, 1)
atomic.CompareAndSwapInt32(&b.ring.wpos, b.ring.size, 0)
next := b.ring.buffers[b.ring.wpos]
next.preparePut()
atomic.SwapInt32(&b.readonly, 1)
b.lock.Unlock()
return next
}
func (i *Instance) Delete(close bool) error {
if !i.Close() {
return nil
}
if err := os.RemoveAll(i.root); err != nil {
return logex.Trace(err)
}
if !close { // reopen
os.MkdirAll(i.root, 0777)
atomic.SwapInt32(&i.closed, 0)
}
return nil
}
func main() {
var a int32 = 10
atomic.AddInt32(&a, 63)
b := atomic.SwapInt32(&a, 44)
fmt.Println(b)
fmt.Println(a)
if atomic.CompareAndSwapInt32(&a, 10, 12) {
fmt.Println(a)
fmt.Println("ok")
} else {
fmt.Println("err")
}
}
// handleGoAway is invokde for a typeGoAway frame
func (s *Session) handleGoAway(hdr header) error {
code := hdr.Length()
switch code {
case goAwayNormal:
atomic.SwapInt32(&s.remoteGoAway, 1)
case goAwayProtoErr:
s.logger.Printf("[ERR] yamux: received protocol error go away")
return fmt.Errorf("yamux protocol error")
case goAwayInternalErr:
s.logger.Printf("[ERR] yamux: received internal error go away")
return fmt.Errorf("remote yamux internal error")
default:
s.logger.Printf("[ERR] yamux: received unexpected go away")
return fmt.Errorf("unexpected go away received")
}
return nil
}
func (poll *Polling) onPollRequest(req *Request) {
res := req.res
if atomic.SwapInt32(&poll.reqGuard, 1) != 0 {
debug("request overlap")
poll.onError("overlap from client", "")
res.WriteHeader(500)
return
}
defer atomic.StoreInt32(&poll.reqGuard, 0)
debug("setting request")
timeout := make(chan bool, 1)
select {
case poll.readyCh <- true:
default:
}
poll.Emit("drain")
if poll.shouldClose != nil {
poll.tryWritable(func() {
debug("triggering empty send to append close packet")
poll.send([]*parser.Packet{&noopPkt})
}, nil)
}
var data []byte = nil
select {
case data = <-poll.writeCh:
case <-timeout:
}
poll.doWrite(req, data)
close(timeout)
select {
case <-poll.readyCh:
default:
}
}
func watchKey(kv kvdb.Kvdb, t *testing.T) {
fmt.Println("\nwatchKey")
watchData := watchData{
t: t,
key: "tree/key1",
otherKey: "tree/otherKey1",
stop: "stop",
iterations: 2,
}
kv.Delete(watchData.key)
kv.Delete(watchData.otherKey)
// First create a key. We should not get update for this create.
_, err := kv.Create(watchData.otherKey, []byte("bar"), 0)
// Let the create operation finish and then start the watch
time.Sleep(time.Second)
err = kv.WatchKey(watchData.otherKey, 0, &watchData, watchFn)
if err != nil {
fmt.Printf("Cannot test watchKey: %v\n", err)
return
}
err = kv.WatchKey(watchData.key, 0, &watchData, watchFn)
if err != nil {
fmt.Printf("Cannot test watchKey: %v\n", err)
return
}
go watchUpdate(kv, &watchData)
for watchData.watchStopped == false {
time.Sleep(time.Millisecond * 100)
}
// Stop the second watch
atomic.SwapInt32(&watchData.whichKey, 0)
watchData.action = kvdb.KVCreate
_, err = kv.Create(watchData.otherKey, []byte(watchData.stop), 0)
}
func (poll *Polling) onDataRequest(req *Request) {
res := req.res
if atomic.SwapInt32(&poll.dataGuard, 1) != 0 {
debug("data request overlap from client")
poll.onError("data request overlap from client", "")
res.WriteHeader(500)
return
}
chunks := new(bytes.Buffer)
buffer := make([]byte, 4096)
for {
length, err := req.httpReq.Body.Read(buffer)
if length+chunks.Len() > poll.maxHTTPBufferSize {
chunks.Reset()
req.httpReq.Body.Close()
req.httpReq.Close = true
} else {
chunks.Write(buffer[:length])
}
if err != nil {
break
}
}
debug("data request onEnd ok. data.len = ", chunks.Len())
go poll.onData(chunks.Next(chunks.Len()))
res.Header().Set("Content-Length", "2")
res.Header().Set("Content-Type", "text/html")
poll.headers(req)
res.WriteHeader(200)
res.Write([]byte("ok"))
atomic.StoreInt32(&poll.dataGuard, 0)
}
// goAway is used to send a goAway message
func (s *Session) goAway(reason uint32) header {
atomic.SwapInt32(&s.localGoAway, 1)
hdr := header(make([]byte, headerSize))
hdr.encode(typeGoAway, 0, 0, reason)
return hdr
}
// Swap sets the value of the boolean to true or false and returns the old value
func (b *Bool) Swap(value bool) bool {
if value {
return atomic.SwapInt32(&b.value, 1) != 0
}
return atomic.SwapInt32(&b.value, 0) != 0
}
// Swap atomically swaps the wrapped int32 and returns the old value.
func (i *Int32) Swap(n int32) int32 {
return atomic.SwapInt32(&i.v, n)
}
func SwapInt32(addr *int32, new int32) int32 {
return orig.SwapInt32(addr, new)
}
func lock() {
for atomic.SwapInt32(&mutex, 1) == 1 {
} // While it returns 1
}