コード例 #1
0
        /// <summary>
        /// Try to add a consumer to the queue.
        /// </summary>
        /// <param name="callback">Consumer to add to queue.</param>
        /// <returns>Always returns <see langword="True"/>.</returns>
        public bool TryEnqueue(Action <T> callback)
        {
            if (callback == null)
            {
                throw new ArgumentNullException("callback");
            }
            SingleLinkNode <object> newTail = null;

            while (true)
            {
                // check if we have an item ready
                T item;
                if (TryDequeueItem(out item))
                {
                    callback(item);
                    return(true);
                }

                // try to enqueue the callback
                newTail = newTail ?? new SingleLinkNode <object>(callback);
                if (TryEnqueueConsumer(newTail))
                {
                    return(true);
                }
            }
        }
コード例 #2
0
        //--- Methods ---

        /// <summary>
        /// Try to push a new item on top of the stack.
        /// </summary>
        /// <param name="item">Item to add.</param>
        /// <returns><see langword="True"/> if the push succeeded.</returns>
        public bool TryPush(T item)
        {
            SingleLinkNode <T> newNode = new SingleLinkNode <T>(item);

            do
            {
                newNode.Next = _head;
            } while(!SysUtil.CAS(ref _head, newNode.Next, newNode));
            return(true);
        }
コード例 #3
0
        private bool TryDequeueConsumer(out Action <T> callback)
        {
            // TODO (arnec): should convert return to enum to indicate contention vs. empty queue

            // loop until we successfully dequeue a node or the queue is empty
            while (true)
            {
                // capture the current state of the queue
                SingleLinkNode <object> curHead     = _head;
                SingleLinkNode <object> curHeadNext = curHead.Next;
                SingleLinkNode <object> curTail     = _tail;

                // check if the current head and tail are equal
                if (ReferenceEquals(curHead, curTail))
                {
                    // check if the current head has a non-empty Next reference
                    if (curHeadNext == null)
                    {
                        // unable to find an item in the queue
                        callback = null;
                        return(false);
                    }

                    // tail reference was not properly updated in an earlier attempt, update it now (see note above)
                    SysUtil.CAS(ref _tail, curTail, curHeadNext);
                }
                else if (curHeadNext == null)
                {
                    // head and tail differ, but we have no next, i.e. contention changed the queue before we
                    // captured its state
                    callback = null;
                    return(false);
                }
                else if (curHeadNext.Item is Action <T> )
                {
                    // try to replace the current head with the current head's Next reference
                    if (SysUtil.CAS(ref _head, curHead, curHeadNext))
                    {
                        // we have successfully retrieved the head of the queue
                        callback = (Action <T>)curHeadNext.Item;

                        // clear out the Item field so the GC can reclaim the memory
                        curHeadNext.Item = default(T);
                        return(true);
                    }
                }
                else
                {
                    // head contains an item instead of a callback
                    callback = null;
                    return(false);
                }
            }
        }
コード例 #4
0
        /// <summary>
        /// Get a string instance from the table for the provided token, if it exists
        /// </summary>
        /// <param name="token">Token to look up or store in the name table</param>
        /// <returns>String instance for token or null, if the token was not found.</returns>
        public override string Get(string token)
        {
            // check for the empty string and always return the built-in constant for it
            if (token.Length == 0)
            {
                return(string.Empty);
            }

            // locate entry based on hashcode of the supplied token
            int hashcode = token.GetAlternativeHashCode();
            int index    = GetIndex(hashcode);
            SingleLinkNode <Entry> current = _buckets[index];

            // check if we're looking for a short string (in that case, we skip the hashcode check)
            if (token.Length < 12)
            {
                // loop over all nodes until we exhaust them or find a match
                for (; current != null; current = current.Next)
                {
                    // do only an ordinal string comparison since the token is short
                    if (CompareStringToString(current.Item.Token, token) == 0)
                    {
                        return(current.Item.Token);
                    }
                }
            }
            else
            {
                // loop over all nodes until we exhaust them or find a match
                for (; current != null; current = current.Next)
                {
                    // do only an ordinal string comparison since the token is short
                    if ((current.Item.HashCode == hashcode) && (CompareStringToString(current.Item.Token, token) == 0))
                    {
                        return(current.Item.Token);
                    }
                }
            }

            // token was not found
            return(null);
        }
コード例 #5
0
        //--- Methods ---

        /// <summary>
        /// Try to add an item to the queue.
        /// </summary>
        /// <param name="item">Item to add to queue.</param>
        /// <returns>Always returns <see langword="True"/>.</returns>
        public bool TryEnqueue(T item)
        {
            SingleLinkNode <object> newTail = null;

            while (true)
            {
                // check if we have a consumer ready
                Action <T> consumer;
                if (TryDequeueConsumer(out consumer))
                {
                    consumer(item);
                    return(true);
                }

                // try to enqueue the item
                newTail = newTail ?? new SingleLinkNode <object>(item);
                if (TryEnqueueItem(newTail))
                {
                    return(true);
                }
            }
        }
コード例 #6
0
        private bool TryEnqueueConsumer(SingleLinkNode <object> newTail)
        {
            // loop until we successful enqueue the new tail node
            while (true)
            {
                // capture the current tail reference and its current Next reference
                SingleLinkNode <object> curHead     = _head;
                SingleLinkNode <object> curTail     = _tail;
                SingleLinkNode <object> curTailNext = curTail.Next;

                // check if the current tail is indeed the last node
                if (curTailNext == null)
                {
                    // ensure if the queue is not empty, that it contains items of the expected type
                    if (!ReferenceEquals(curHead, curTail) && !(curTail.Item is Action <T>))
                    {
                        return(false);
                    }

                    // update the tail's Next reference to point to the new entry
                    if (SysUtil.CAS(ref _tail.Next, null, newTail))
                    {
                        // NOTE (steveb): there is a race-condition here where we may update the tail to point a non-terminal node; that's ok

                        // update the tail reference to the new entry (may fail)
                        SysUtil.CAS(ref _tail, curTail, newTail);
                        return(true);
                    }
                }
                else
                {
                    // tail reference was not properly updated in an earlier attempt, update it now (see note above)
                    SysUtil.CAS(ref _tail, curTail, curTailNext);
                }
            }
        }
コード例 #7
0
        //--- Constructors ---

        /// <summary>
        /// Create a new instance of the queue.
        /// </summary>
        public LockFreeQueue()
        {
            _head = new SingleLinkNode <T>();
            _tail = _head;
        }
コード例 #8
0
        //--- Constructors ---

        /// <summary>
        /// Create a new instance of the queue.
        /// </summary>
        public LockFreeItemConsumerQueue()
        {
            _head = new SingleLinkNode <object>();
            _tail = _head;
        }
コード例 #9
0
        /// <summary>
        /// Add a token to the name table and get the common string instance it represents.
        /// </summary>
        /// <remarks>
        /// If the token already exists in the name table, the existing instance is returned.
        /// </remarks>
        /// <param name="token">The token to add.</param>
        /// <returns>String instance for the token.</returns>
        public override string Add(string token)
        {
            // check for the empty string and always return the built-in constant for it
            if (token.Length == 0)
            {
                return(string.Empty);
            }

            // locate entry based on hashcode of the supplied token
            int hashcode = token.GetAlternativeHashCode();
            int index    = GetIndex(hashcode);
            SingleLinkNode <Entry> current = _buckets[index];
            SingleLinkNode <Entry> entry   = null;

            // check if a head node exists for the given hashcode
            if (current == null)
            {
                entry = new SingleLinkNode <Entry>(new Entry(hashcode, token));

                // try to update the head node with the new entry
                current = Interlocked.CompareExchange(ref _buckets[index], entry, null);

                // check if we succeeded, which means the provided token is now the reference token
                if (current == null)
                {
                    return(token);
                }

                // otherwise, continue on since 'current' now has the updated head node
            }

            // loop until we successfully find or append the token
            SingleLinkNode <Entry> previous = null;

            while (true)
            {
                // check if we're looking for a short string (in that case, we skip the hashcode check)
                if (token.Length < 12)
                {
                    // loop over all entries until we exhaust them or find a match
                    for (; current != null; current = current.Next)
                    {
                        // do only an ordinal string comparison since the token is short
                        if (CompareStringToString(current.Item.Token, token) == 0)
                        {
                            return(current.Item.Token);
                        }
                        previous = current;
                    }
                }
                else
                {
                    // loop over all entries until we exhaust them or find a match
                    for (; current != null; current = current.Next)
                    {
                        // do only an ordinal string comparison since the token is short
                        if ((current.Item.HashCode == hashcode) && (CompareStringToString(current.Item.Token, token) == 0))
                        {
                            return(current.Item.Token);
                        }
                        previous = current;
                    }
                }

                // NOTE: it's possible that an earlier attempt already initialized 'entry'
                entry = entry ?? new SingleLinkNode <Entry>(new Entry(hashcode, token));

                // try to update the previous node with the new entry
                current = Interlocked.CompareExchange(ref previous.Next, entry, null);

                // check if we succeeded, which means the provided token is now the reference token
                if (current == null)
                {
                    // provided token was added
                    return(token);
                }

                // otherwise, continue on since 'current' now has the updated next node
            }
        }