예제 #1
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// reuse the current transaction's created rec-lock
        /// </summary>
        /// <param name="ctx"></param>
        /// <returns></returns>
        private LockEntry GetCanReuseRecLock(ref LockContext ctx)
        {
            var entry = default(LockEntry);
            var locks = RecLocks.GetValueOrDefault(ctx.Page);

            if (locks == null)
            {
                return(null);
            }

            for (var node = locks.First; node != null; node = node.Next)
            {
                var lockEntry = node.Value;
                if (lockEntry.Transaction == ctx.Transaction &&
                    lockEntry.IsExclusive == ctx.Flags.IsExclusive())
                {
                    entry = lockEntry;
                    break;
                }
            }

            if (entry != null)
            {
                entry.SetBit(ctx.RecordIndex, 1);
            }

            return(entry);
        }
예제 #2
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// create new rec lock then waitting
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="entry"></param>
        /// <returns></returns>
        private DBResult CreateRecLockForWait(ref LockContext ctx, out LockEntry entry)
        {
            var recEntry = CreateRecLock(ref ctx);

            if (!recEntry.IsWaiting)
            {
                recEntry.Flags |= LockFlags.Waiting;
            }

            entry = recEntry;
            entry.Transaction.WaitLock = recEntry;
            entry.Transaction.State    = TransactionState.Waitting;

            //check dead-lock
            if (IsCausedDeadLock(recEntry))
            {
                entry.Flags &= ~LockFlags.Waiting;
                entry.SetBit(ctx.RecordIndex, 0);
                entry.Transaction.WaitLock = null;
                return(DBResult.DeadLock);
            }

            entry.Transaction.WaitEvent.Reset();
            return(DBResult.WaitLock);
        }
예제 #3
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// create a new table-lock
        /// </summary>
        /// <param name="ctx"></param>
        /// <returns></returns>
        private LockEntry CreateTabLock(ref LockContext ctx)
        {
            if (!TabLocks.TryGetValue(ctx.Index, out var list))
            {
                list = new LinkedList <LockEntry>();
                TabLocks[ctx.Index] = list;;
            }

            var tx    = ctx.Transaction;
            var entry = new LockEntry(ctx.Page, ctx.Flags, ctx.RecordCount);

            if (entry.IsWaiting)
            {
                tx.WaitLock = entry;
            }

            list.AddLast(entry);
            tx.Locks.AddLast(entry);

            entry.GNode       = list.Last;
            entry.TNode       = tx.Locks.Last;
            entry.Index       = ctx.Index;
            entry.Transaction = ctx.Transaction;
            entry.Thread      = Thread.CurrentThread.ManagedThreadId;

            return(entry);
        }
예제 #4
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// check current transaction has held the table's lock >=ctx-lock-level and not been in wait state
        /// </summary>
        /// <param name="ctx"></param>
        /// <returns></returns>
        private bool IsHeldTabLock(ref LockContext ctx, out LockEntry entry)
        {
            var locks = TabLocks.GetValueOrDefault(ctx.Index);

            if (locks == null)
            {
                entry = null;
                return(false);
            }

            for (var node = locks.First; node != null; node = node.Next)
            {
                var lockEntry = node.Value;
                if (lockEntry.Transaction != ctx.Transaction)
                {
                    continue;
                }

                if (lockEntry.IsExclusive || !ctx.Flags.IsExclusive())
                {
                    entry = lockEntry;
                    return(true);
                }
            }

            entry = null;
            return(false);
        }
예제 #5
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
 /// <summary>
 /// lock a table
 /// </summary>
 /// <param name="ctx"></param>
 /// <returns></returns>
 public DBResult Lock(ref LockContext ctx)
 {
     lock (SyncRoot)
     {
         return(ctx.Flags.IsTable() ? LockTab(ref ctx, out var _) : LockRec(ref ctx, out var _));
     }
 }
예제 #6
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// lock a record
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="entry"></param>
        /// <returns></returns>
        public DBResult LockRec(ref LockContext ctx, out LockEntry entry)
        {
            var locks = RecLocks.GetValueOrDefault(ctx.Page);

            if (locks == null || locks.Count == 0)
            {
                entry = CreateRecLock(ref ctx);
                return(DBResult.Success);
            }

            if (IsHeldTabLock(ref ctx, out entry))
            {
                return(DBResult.Success);
            }

            if (IsHeldRecLock(ref ctx, out entry))
            {
                return(DBResult.Success);
            }

            if (IsOthersHeldOrWaitConflictRecLock(ctx.Transaction, ctx.Page, ctx.RecordIndex, ctx.Flags))
            {
                ctx.Flags |= LockFlags.Waiting;
                return(CreateRecLockForWait(ref ctx, out entry));
            }

            entry = GetCanReuseRecLock(ref ctx) ?? CreateRecLock(ref ctx);

            return(DBResult.Success);
        }
예제 #7
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// create new rec lock then waitting
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="entry"></param>
        /// <returns></returns>
        private DBResult CreateTabLockForWait(ref LockContext ctx, out LockEntry entry)
        {
            var tabEntry = CreateTabLock(ref ctx);

            if (!tabEntry.IsWaiting)
            {
                tabEntry.Flags |= LockFlags.Waiting;
            }

            entry = tabEntry;
            entry.Transaction.WaitLock = tabEntry;
            entry.Transaction.State    = TransactionState.Waitting;

            //check dead-lock
            if (IsCausedDeadLock(tabEntry))
            {
                entry.Flags &= ~LockFlags.Waiting;
                entry.Transaction.WaitLock = null;
                return(DBResult.DeadLock);
            }

            entry.Transaction.WaitEvent.Reset();
            return(DBResult.WaitLock);
        }
예제 #8
0
파일: LockManager.cs 프로젝트: zuvys/Vicuna
        /// <summary>
        /// lock a table
        /// </summary>
        /// <param name="ctx"></param>
        /// <param name="entry"></param>
        /// <returns></returns>
        public DBResult LockTab(ref LockContext ctx, out LockEntry entry)
        {
            var locks = TabLocks.GetValueOrDefault(ctx.Index);

            if (locks == null || locks.Count == 0)
            {
                entry = CreateTabLock(ref ctx);
                return(DBResult.Success);
            }

            if (IsHeldTabLock(ref ctx, out entry))
            {
                return(DBResult.Success);
            }

            if (IsOthersHeldOrWaitConflictTabLock(ctx.Transaction, ctx.Index, ctx.Flags))
            {
                ctx.Flags |= LockFlags.Waiting;
                return(CreateTabLockForWait(ref ctx, out entry));
            }

            entry = CreateTabLock(ref ctx);
            return(DBResult.Success);
        }