예제 #1
0
 internal void TransformList <T>(ref StructList <T> list) where T : AstNode
 {
     for (var i = 0; i < list.Count; i++)
     {
         var originalNode = list[i];
         var item         = Transform(originalNode, true);
         if (item == Remove)
         {
             list.RemoveAt(i);
             Modified = true;
             i--;
         }
         else if (item is AstSpreadStructList <T> spreadList)
         {
             list.ReplaceItemAt(i, spreadList.NodeList);
             Modified = true;
         }
         else
         {
             if (originalNode != item)
             {
                 Modified = true;
             }
             list[i] = (T)item;
         }
     }
 }
예제 #2
0
    public void Sort()
    {
        for (var i = 0; i < Infos.Count; i++)
        {
            var info = Infos[i];
            if (info.Start != info.End)
            {
                continue;
            }
            Infos.RemoveAt(i);
            i--;
        }

        Infos = new StructList <InstrumentedInfo>(Infos.OrderBy(i => i.Start).ToArray());
    }
예제 #3
0
 public void CleanupForThisFrame()
 {
     for (int i = m_KeyStates.size - 1; i >= 0; i--)
     {
         ref KeyCodeState mKeyState = ref m_KeyStates.array[i];
         if (mKeyState.keyState == KeyState.Up || (mKeyState.keyState & KeyState.UpThisFrame) != 0)
         {
             m_KeyStates.RemoveAt(i);
         }
         else if ((mKeyState.keyState & KeyState.DownThisFrame) != 0)
         {
             if (UnityEngine.Input.GetKey(mKeyState.keyCode))
             {
                 mKeyState.keyState = KeyState.Down;
             }
             else
             {
                 mKeyState.keyState = KeyState.UpThisFrame;
             }
         }
     }
예제 #4
0
        internal bool Run()
        {
            if (_keyValueDB.FileCollection.GetCount() == 0)
            {
                return(false);
            }
            _root = _keyValueDB.ReferenceAndGetOldestRoot();
            try
            {
                var dontTouchGeneration = _keyValueDB.GetGeneration(_keyValueDB.GetTrLogFileId(_root));
                var preserveKeyIndexKey =
                    _keyValueDB.CalculatePreserveKeyIndexKeyFromKeyIndexInfos(_keyValueDB.BuildKeyIndexInfos());
                var preserveKeyIndexGeneration = _keyValueDB.CalculatePreserveKeyIndexGeneration(preserveKeyIndexKey);
                InitFileStats(dontTouchGeneration);
                long[] usedFilesFromOldGenerations = null;
                if (preserveKeyIndexKey < uint.MaxValue)
                {
                    var dontTouchGenerationDueToPreserve = -1L;
                    if (_keyValueDB.FileCollection.FileInfoByIdx(preserveKeyIndexKey) is IKeyIndex fileInfo)
                    {
                        dontTouchGenerationDueToPreserve = fileInfo.Generation;
                        dontTouchGenerationDueToPreserve = Math.Min(dontTouchGenerationDueToPreserve,
                                                                    _keyValueDB.GetGeneration(fileInfo.TrLogFileId));
                        if (fileInfo.UsedFilesInOlderGenerations == null)
                        {
                            _keyValueDB.LoadUsedFilesFromKeyIndex(preserveKeyIndexKey, fileInfo);
                        }
                        usedFilesFromOldGenerations = fileInfo.UsedFilesInOlderGenerations;
                    }

                    dontTouchGeneration = Math.Min(dontTouchGeneration, dontTouchGenerationDueToPreserve);
                }

                var lastCommitted = _keyValueDB.ReferenceAndGetLastCommitted();
                try
                {
                    if (_root != lastCommitted)
                    {
                        ForbidDeleteOfFilesUsedByStillRunningOldTransaction();
                    }
                    ForbidDeletePreservingHistory(dontTouchGeneration, usedFilesFromOldGenerations);
                    CalculateFileUsefulness(lastCommitted);
                }
                finally
                {
                    _keyValueDB.DereferenceRootNodeInternal(lastCommitted);
                }

                MarkTotallyUselessFilesAsUnknown();
                var totalWaste = CalcTotalWaste();
                _keyValueDB.Logger?.CompactionStart(totalWaste);
                if (IsWasteSmall(totalWaste))
                {
                    if (_keyValueDB.DistanceFromLastKeyIndex(_root) > (ulong)(_keyValueDB.MaxTrLogFileSize / 4))
                    {
                        _keyValueDB.CreateIndexFile(_cancellation, preserveKeyIndexGeneration);
                    }
                    _keyValueDB.FileCollection.DeleteAllUnknownFiles();
                    return(false);
                }

                long btreesCorrectInTransactionId;
                var  toRemoveFileIds = new StructList <uint>();
                do
                {
                    _newPositionMap = new Dictionary <ulong, ulong>();
                    do
                    {
                        CompactOnePureValueFileIteration(ref toRemoveFileIds);
                        totalWaste = CalcTotalWaste();
                    } while (_newPositionMap.Count * 50 / (1024 * 1024) < _keyValueDB.CompactorRamLimitInMb &&
                             !IsWasteSmall(totalWaste));

                    btreesCorrectInTransactionId = _keyValueDB.ReplaceBTreeValues(_cancellation, _newPositionMap);
                } while (!IsWasteSmall(totalWaste));

                var usedFileGens = _keyValueDB.CreateIndexFile(_cancellation, preserveKeyIndexGeneration);
                for (var i = (int)toRemoveFileIds.Count - 1; i >= 0; i--)
                {
                    if (usedFileGens.IndexOf(_keyValueDB.FileCollection.FileInfoByIdx(toRemoveFileIds[i])?.Generation ??
                                             0) >= 0)
                    {
                        _keyValueDB.Logger?.LogWarning("Disaster prevented by skipping delete of " +
                                                       toRemoveFileIds[i] + " file which is used by new kvi");
                        Debug.Fail("Should not get here");
                        toRemoveFileIds.RemoveAt(i);
                    }
                }

                _keyValueDB.DereferenceRootNodeInternal(_root);
                _root = null;
                if (_keyValueDB.AreAllTransactionsBeforeFinished(btreesCorrectInTransactionId))
                {
                    _keyValueDB.MarkAsUnknown(toRemoveFileIds);
                }

                if (!_cancellation.IsCancellationRequested)
                {
                    _keyValueDB.FileCollection.DeleteAllUnknownFiles();
                }
                return(true);
            }
            finally
            {
                if (_root != null)
                {
                    _keyValueDB.DereferenceRootNodeInternal(_root);
                }
                _root = null;
            }
        }