Exemple #1
0
        public Task <bool> WaitAsyncEx(int timeout, CancellationToken ctk)
        {
            lock (_lock)
            {
                if (currentPermits > 0)
                {
                    currentPermits -= 1;
                    return(TrueTask);
                }
                // the current thread must block, so check immediate cancelers
                if (timeout == 0)
                {
                    return(FalseTask);
                }
                ctk.ThrowIfCancellationRequested();

                var waiter = new Waiter(ctk);
                DListNode.AddLast(waiters, waiter);
                // enable timeout or cancellation only after the node is in the list
                if (ctk.CanBeCanceled)
                {
                    waiter.ctkReg = ctk.Register(OnCancellation, waiter);
                }
                if (timeout != Timeout.Infinite)
                {
                    waiter.timer = new Timer(OnTimeout, waiter, timeout, Timeout.Infinite);
                }
                return(waiter.tcs.Task);
            }
        }
 private void AsyncUnlink(DListNode waiter)
 {
     lock (_lock)
     {
         DListNode.RemoveIfInserted(waiter);
     }
 }
        //---------------------------------------------------------------------
        // APM
        //--
        public IAsyncResult BeginWaitEx(int timeout, CancellationToken ctk,
                                        AsyncCallback ucb, object ustate)
        {
            bool result = true;

            lock (_lock)
            {
                if (currentPermits > 0)
                {
                    currentPermits -= 1;
                }
                else if (timeout == 0 || ctk.IsCancellationRequested)
                {
                    result = false;
                }
                else
                {
                    var waiter = new ApmWaiter <Data>(new Data(), ucb, ustate, ctk, timeout, AsyncUnlink);
                    DListNode.AddLast(waiters, waiter);
                    waiter.Enable();
                    return(waiter.AsyncResult);
                }
            }
            // FromResult will invoke the async callbacks, so do it outside of the lock
            if (result)
            {
                return(GenericAsyncResult <bool> .FromResult(ucb, ustate, true, null, true));
            }
            // synchronous completion due to timeout or cancellation
            return(ctk.IsCancellationRequested ?
                   GenericAsyncResult <bool> .FromResult(ucb, ustate, false, new OperationCanceledException(ctk), true) :
                   GenericAsyncResult <bool> .FromResult(ucb, ustate, false, null, true));
        }
Exemple #4
0
 public void AddNode(DListNode node)
 {
     node.Pre      = tail.Pre;
     node.Next     = tail;
     tail.Pre.Next = node;
     tail.Pre      = node;
 }
 private void SyncUnlink(DListNode waiter)
 {
     lock (_lock)
     {
         DListNode.RemoveIfInserted(waiter);
         MonitorEx.PulseAll(_lock, waiter);
     }
 }
Exemple #6
0
    // Inserts the specified entry at the tail of the list.
    public static void AddLast(DListNode list, DListNode entry)
    {
        DListNode prev = list.prev;

        entry.next = list;
        entry.prev = prev;
        prev.next  = entry;
        list.prev  = entry;
    }
Exemple #7
0
    // Removes the entry that is at the tail of the list.
    public static DListNode RemoveLast(DListNode list)
    {
        DListNode entry = list.prev, prev = entry.prev;

        list.prev  = prev;
        prev.next  = list;
        entry.next = entry.prev = null;                 // mark as removed and help GC!
        return(entry);
    }
Exemple #8
0
    // Removes the entry that is at the front of the list.
    public static DListNode RemoveFirst(DListNode list)
    {
        DListNode entry = list.next, next = entry.next;

        list.next  = next;
        next.prev  = list;
        entry.next = entry.prev = null;                 // mark as removed!
        return(entry);
    }
Exemple #9
0
    // Removes the specified entry from the list that contains it.
    public static bool Remove(DListNode entry)
    {
        DListNode next = entry.next, prev = entry.prev;

        next.prev  = prev;
        prev.next  = next;
        entry.next = entry.prev = null;                 // mark as removed!
        return(next == prev);
    }
Exemple #10
0
    // Inserts the specified entry at the head of the list.
    public static void AddFirst(DListNode list, DListNode entry)
    {
        DListNode next = list.next;

        entry.next = next;
        entry.prev = list;
        next.prev  = entry;
        list.next  = entry;
    }
        private bool TrySetStateAndRemoveWaiter(Waiter <Data> waiter, int state)
        {
            bool res = waiter.TrySetState(state);

            if (res)
            {
                DListNode.RemoveIfInserted(waiter);
            }
            return(res);
        }
Exemple #12
0
 public LRUCache(int capacity)
 {
     _lruValDic = new Dictionary <int, DListNode>(capacity);
     _size      = capacity;
     head       = new DListNode(-1, -1);
     tail       = new DListNode(-1, -1);
     head.Next  = tail;
     head.Pre   = tail;
     tail.Next  = head;
     tail.Pre   = head;
 }
Exemple #13
0
    // Removes the specified entry if it is inserted in the list.
    public static bool RemoveIfInserted(DListNode entry)
    {
        DListNode next, prev;

        if ((next = entry.next) == null)
        {
            return(false);
        }
        prev       = entry.prev;
        next.prev  = prev;
        prev.next  = next;
        entry.next = entry.prev = null;                 // mark as removed!
        return(true);
    }
 public SemaphoreAsync(int initial, int maximum)
 {
     if (initial < 0 || initial > maximum)
     {
         throw new ArgumentOutOfRangeException("initial");
     }
     if (maximum <= 0)
     {
         throw new ArgumentOutOfRangeException("maximum");
     }
     maxPermits     = maximum;
     currentPermits = initial;
     DListNode.InitializeList(waiters);
 }
Exemple #15
0
        public void Release()
        {
            Waiter toFinish = null;

            lock (_lock)
            {
                if (currentPermits + 1 > maxPermits)
                {
                    throw new ArgumentOutOfRangeException("releases");
                }
                currentPermits += 1;
                Waiter waiter;
                while ((waiter = (Waiter)DListNode.FirstEntry(waiters)) != null)
                {
                    if (Volatile.Read(ref waiter.state) != WAITING)
                    {
                        DListNode.RemoveIfInserted(waiter);
                        continue;
                    }
                    if (waiter.TrySetState(SUCCESS))
                    {
                        DListNode.RemoveIfInserted(waiter);
                        currentPermits -= 1;
                        toFinish        = waiter;
                        break;
                    }
                }
            }
            // finish it outside the lock
            if (toFinish != null)
            {
                // cancel the active cancelers
                if (toFinish.ctkReg != null)
                {
                    toFinish.ctkReg.Dispose();
                }
                if (toFinish.timer != null)
                {
                    toFinish.timer.Dispose();
                }
                toFinish.tcs.SetResult(true);
            }
        }
Exemple #16
0
        public void OnCancellation(object state)
        {
            var waiter = (Waiter)state;

            if (waiter.TrySetState(CANCELED))
            {
                if (DListNode.IsInList(waiter))
                {
                    lock (_lock)
                    {
                        DListNode.RemoveIfInserted(waiter);
                    }
                }
                if (waiter.timer != null)
                {
                    waiter.timer.Dispose();
                }
                waiter.tcs.SetCanceled();
            }
        }
Exemple #17
0
 public void Put(int key, int value)
 {
     if (_lruValDic.TryGetValue(key, out DListNode outNode))
     {
         outNode.val = value;
         RemoveNode(outNode);
         AddNode(outNode);
     }
     else
     {
         var newDNode = new DListNode(key, value);
         AddNode(newDNode);
         _lruValDic.Add(key, newDNode);
         if (_lruValDic.Count > _size)
         {
             _lruValDic.Remove(head.Next.Key);
             RemoveNode(head.Next);
         }
     }
 }
Exemple #18
0
        public void OnTimeout(object state)
        {
            var waiter = (Waiter)state;

            if (waiter.TrySetState(CANCELED))
            {
                if (DListNode.IsInList(waiter))
                {
                    lock (_lock)
                    {
                        DListNode.RemoveIfInserted(waiter);
                    }
                }
                if (waiter.ctkReg != null)
                {
                    waiter.ctkReg.Dispose();
                }
                waiter.timer.Dispose();
                waiter.tcs.SetResult(false);
            }
        }
        //---------------------------------------------------------------------
        // TAP
        //--

        public Task <bool> WaitAsyncEx(int timeout, CancellationToken ctk)
        {
            lock (_lock)
            {
                if (currentPermits > 0)
                {
                    currentPermits -= 1;
                    return(TrueTask);
                }
                // the current thread must block, so check immediate cancelers
                if (timeout == 0)
                {
                    return(FalseTask);
                }
                ctk.ThrowIfCancellationRequested();

                var waiter = new TapWaiter <Data>(new Data(), ctk, timeout, AsyncUnlink);
                DListNode.AddLast(waiters, waiter);
                waiter.Enable();
                return(waiter.Task);
            }
        }
        public void Release()
        {
            Waiter <Data> toFinish = null;

            lock (_lock)
            {
                if (currentPermits + 1 > maxPermits)
                {
                    throw new ArgumentOutOfRangeException("releases");
                }
                currentPermits += 1;
                Waiter <Data> waiter;
                while ((waiter = (Waiter <Data>)DListNode.FirstEntry(waiters)) != null)
                {
                    if (Volatile.Read(ref waiter.state) != WaiterState.WAITING)
                    {
                        // Shouldn't already be on the queue, ensure it is removed
                        DListNode.RemoveIfInserted(waiter);
                        continue;
                    }
                    if (waiter.TrySetStateAndUnlink(WaiterState.SUCCESS))
                    {
                        currentPermits -= 1;
                        // queue node for further processing outside the lock
                        waiter.prev = toFinish;
                        toFinish    = waiter;
                        break;
                    }
                }
            }
            // finish the stack of satisfied requests
            while (toFinish != null)
            {
                toFinish.OnSuccess();
                toFinish = (Waiter <Data>)toFinish.prev;
            }
        }
Exemple #21
0
 public void RemoveNode(DListNode node)
 {
     node.Pre.Next = node.Next;
     node.Next.Pre = node.Pre;
 }
        //---------------------------------------------------------------------
        // Synchronous
        //--
        public bool WaitEx(int timeout, CancellationToken ctk)
        {
            bool          interrupted   = false;
            Waiter <Data> waiter        = null;
            bool          ownsTheWaiter = false;

            lock (_lock)
            {
                if (currentPermits > 0)
                {
                    currentPermits -= 1;
                    return(true);
                }
                // if the current thread must block, check immediate cancelers
                if (timeout == 0)
                {
                    return(false);
                }
                ctk.ThrowIfCancellationRequested();

                // create a synchronous waiter node and insert it in the wait queue
                waiter = new SyncWaiter <Data>(new Data(), ctk, SyncUnlink);
                DListNode.AddLast(waiters, waiter);
                waiter.Enable();

                // wrap timeout value with timeout holder, in order to support timeout adjust
                TimeoutHolder th = new TimeoutHolder(timeout);

                // wait until the request is staisfied, timeout expires or cancellation
                do
                {
                    try
                    {
                        if ((timeout = th.Value) == 0)
                        {
                            ownsTheWaiter = TrySetStateAndRemoveWaiter(waiter, WaiterState.TIMED_OUT);
                            break;
                        }
                        // wait on the monitor's condition variable
                        MonitorEx.Wait(_lock, waiter, timeout);
                    }
                    catch (ThreadInterruptedException)
                    {
                        interrupted   = true;
                        ownsTheWaiter = TrySetStateAndRemoveWaiter(waiter, WaiterState.INTERRUPTED);
                        break;
                    }
                } while (waiter.State == WaiterState.WAITING);
            }

            // this processing is private of the current thread, so we can do it without
            // owning the lock.
            if (ownsTheWaiter)
            {
                waiter.CancelCancellation();
            }
            if (waiter.State == WaiterState.INTERRUPTED)
            {
                throw new ThreadInterruptedException();
            }
            if (interrupted)
            {
                Thread.CurrentThread.Interrupt();
            }
            if (waiter.State == WaiterState.CANCELED)
            {
                throw new OperationCanceledException(ctk);
            }
            return(waiter.State == WaiterState.SUCCESS);
        }
Exemple #23
0
 // Initializes a doubly-linked list.
 public static void InitializeList(DListNode list)
 {
     list.next = list.prev = list;
 }
Exemple #24
0
 // Returns the first entry of the list or null if the list is empty
 public static DListNode FirstEntry(DListNode list)
 {
     return(list.next == list ? null : list.next);
 }
Exemple #25
0
 // Returns true if the specified list is empty.
 public static bool IsListEmpty(DListNode list)
 {
     return(list.next == list);
 }
Exemple #26
0
 // Returns true of the specified ListNode is in a list
 public static bool IsInList(DListNode entry)
 {
     return(Volatile.Read(ref entry.next) == null);
 }