public override void Print() { const string asciiHeader = @" _____ _____ ____ {0} | __ \ | __ \| _ \ {0} | |__) |__ ___ _____ _ __ | | | | |_) |{0} | _ // _` \ \ / / _ \ '_ \| | | | _ < {0} | | \ \ (_| |\ V / __/ | | | |__| | |_) |{0} |_| \_\__,_| \_/ \___|_| |_|_____/|____/ {0}{0}"; ConsoleWriteLineWithColor(ConsoleColor.DarkRed, asciiHeader, Environment.NewLine); ConsoleWriteLineWithColor(ConsoleColor.Cyan, " Safe by default, optimized for efficiency"); _tw.WriteLine(); const string lineBorder = "+---------------------------------------------------------------+"; var meminfo = MemoryInformation.GetMemoryInfo(); ConsoleWriteLineWithColor(ConsoleColor.Yellow, " Build {0}, Version {1}, SemVer {2}, Commit {3}\r\n PID {4}, {5} bits, {6} Cores, Phys Mem {7}, Arch: {8}", ServerVersion.Build, ServerVersion.Version, ServerVersion.FullVersion, ServerVersion.CommitHash, Process.GetCurrentProcess().Id, IntPtr.Size * 8, ProcessorInfo.ProcessorCount, meminfo.TotalPhysicalMemory, RuntimeInformation.OSArchitecture); ConsoleWriteLineWithColor(ConsoleColor.DarkCyan, " Source Code (git repo): https://github.com/ravendb/ravendb"); ConsoleWriteWithColor(new ConsoleText { Message = " Built with ", ForegroundColor = ConsoleColor.Gray }, new ConsoleText { Message = "love ", ForegroundColor = ConsoleColor.Red }, new ConsoleText { Message = "by ", ForegroundColor = ConsoleColor.Gray }, new ConsoleText { Message = "Hibernating Rhinos ", ForegroundColor = ConsoleColor.Yellow }, new ConsoleText { Message = "and awesome contributors!", ForegroundColor = ConsoleColor.Gray, IsNewLinePostPended = true }); _tw.WriteLine(lineBorder); }
public static MachineResources GetMachineResources() { using (var currentProcess = Process.GetCurrentProcess()) { var workingSet = PlatformDetails.RunningOnLinux == false ? currentProcess.WorkingSet64 : MemoryInformation.GetRssMemoryUsage(currentProcess.Id); var memoryInfoResult = MemoryInformation.GetMemoryInfo(); var cpuInfo = CpuUsage.Calculate(); var machineResources = new MachineResources { TotalMemory = memoryInfoResult.TotalPhysicalMemory.GetValue(SizeUnit.Bytes), SystemCommitLimit = memoryInfoResult.TotalCommittableMemory.GetValue(SizeUnit.Bytes), CommitedMemory = memoryInfoResult.CurrentCommitCharge.GetValue(SizeUnit.Bytes), ProcessMemoryUsage = workingSet, IsProcessMemoryRss = PlatformDetails.RunningOnPosix, MachineCpuUsage = cpuInfo.MachineCpuUsage, ProcessCpuUsage = Math.Min(cpuInfo.MachineCpuUsage, cpuInfo.ProcessCpuUsage) // min as sometimes +-1% due to time sampling }; return(machineResources); } }
public static MachineResources GetMachineResources(SmapsReader smapsReader) { using (var currentProcess = Process.GetCurrentProcess()) { var memInfo = MemoryInformation.GetMemoryInfo(smapsReader); var isLowMemory = LowMemoryNotification.Instance.IsLowMemory(memInfo); var workingSet = PlatformDetails.RunningOnLinux ? MemoryInformation.GetRssMemoryUsage(currentProcess.Id) - memInfo.AvailableWithoutTotalCleanMemory.GetValue(SizeUnit.Bytes) : currentProcess.WorkingSet64; var cpuInfo = CpuUsage.Calculate(); var machineResources = new MachineResources { TotalMemory = memInfo.TotalPhysicalMemory.GetValue(SizeUnit.Bytes), AvailableMemory = memInfo.AvailableMemory.GetValue(SizeUnit.Bytes), AvailableWithoutTotalCleanMemory = memInfo.AvailableWithoutTotalCleanMemory.GetValue(SizeUnit.Bytes), SystemCommitLimit = memInfo.TotalCommittableMemory.GetValue(SizeUnit.Bytes), CommittedMemory = memInfo.CurrentCommitCharge.GetValue(SizeUnit.Bytes), ProcessMemoryUsage = workingSet, IsWindows = PlatformDetails.RunningOnPosix == false, IsLowMemory = isLowMemory, LowMemoryThreshold = LowMemoryNotification.Instance.LowMemoryThreshold.GetValue(SizeUnit.Bytes), CommitChargeThreshold = LowMemoryNotification.Instance.GetCommitChargeThreshold(memInfo).GetValue(SizeUnit.Bytes), MachineCpuUsage = cpuInfo.MachineCpuUsage, ProcessCpuUsage = Math.Min(cpuInfo.MachineCpuUsage, cpuInfo.ProcessCpuUsage) // min as sometimes +-1% due to time sampling }; return(machineResources); } }
public static MachineResources GetMachineResources() { var currentProcess = Process.GetCurrentProcess(); var workingSet = PlatformDetails.RunningOnPosix == false || PlatformDetails.RunningOnMacOsx ? currentProcess.WorkingSet64 : MemoryInformation.GetRssMemoryUsage(currentProcess.Id); var memoryInfoResult = MemoryInformation.GetMemoryInfo(); var installedMemory = memoryInfoResult.InstalledMemory.GetValue(SizeUnit.Bytes); var availableMemory = memoryInfoResult.AvailableMemory.GetValue(SizeUnit.Bytes); var mappedSharedMem = LowMemoryNotification.GetCurrentProcessMemoryMappedShared(); var shared = mappedSharedMem.GetValue(SizeUnit.Bytes); var cpuInfo = CpuUsage.Calculate(); var machineResources = new MachineResources { TotalMemory = installedMemory, MachineMemoryUsage = installedMemory - availableMemory, ProcessMemoryUsage = workingSet, ProcessMemoryExcludingSharedUsage = Math.Max(workingSet - shared, 0), MachineCpuUsage = cpuInfo.MachineCpuUsage, ProcessCpuUsage = cpuInfo.ProcessCpuUsage }; return(machineResources); }
public Task GetNodeInfo() { using (ServerStore.ContextPool.AllocateOperationContext(out TransactionOperationContext context)) using (var writer = new BlittableJsonTextWriter(context, ResponseBodyStream())) { var json = new DynamicJsonValue(); using (context.OpenReadTransaction()) { json[nameof(NodeInfo.NodeTag)] = ServerStore.NodeTag; json[nameof(NodeInfo.TopologyId)] = ServerStore.GetClusterTopology(context).TopologyId; json[nameof(NodeInfo.Certificate)] = ServerStore.Server.Certificate.CertificateForClients; json[nameof(ServerStore.Engine.LastStateChangeReason)] = ServerStore.LastStateChangeReason(); json[nameof(NodeInfo.NumberOfCores)] = ProcessorInfo.ProcessorCount; var memoryInformation = MemoryInformation.GetMemoryInfo(); json[nameof(NodeInfo.InstalledMemoryInGb)] = memoryInformation.InstalledMemory.GetDoubleValue(SizeUnit.Gigabytes); json[nameof(NodeInfo.UsableMemoryInGb)] = memoryInformation.TotalPhysicalMemory.GetDoubleValue(SizeUnit.Gigabytes); json[nameof(NodeInfo.BuildInfo)] = LicenseManager.BuildInfo; json[nameof(NodeInfo.ServerId)] = ServerStore.GetServerId().ToString(); json[nameof(NodeInfo.CurrentState)] = ServerStore.CurrentRachisState; } context.Write(writer, json); writer.Flush(); } return(Task.CompletedTask); }
public MemoryConfiguration() { var memoryInfo = MemoryInformation.GetMemoryInfo(); LowMemoryLimit = Size.Min( new Size(2, SizeUnit.Gigabytes), memoryInfo.TotalPhysicalMemory / 10); }
protected override Gauge32 GetData() { lock (this) { var memoryInfo = MemoryInformation.GetMemoryInfo(_smapsReader?.Value, extended: true); return(new Gauge32(memoryInfo.WorkingSet.GetValue(SizeUnit.Megabytes))); } }
public MemoryConfiguration() { var memoryInfo = MemoryInformation.GetMemoryInfo(); LowMemoryLimit = Size.Min( new Size(2, SizeUnit.Gigabytes), memoryInfo.TotalPhysicalMemory / 10); UseRssInsteadOfMemUsage = PlatformDetails.RunningOnDocker; }
public MemoryConfiguration(RavenConfiguration configuration) { var memoryInfo = MemoryInformation.GetMemoryInfo(); // we allow 1 GB by default, or up to 75% of available memory on startup, if less than that is available LimitForProcessing = Size.Min(new Size(1024, SizeUnit.Megabytes), memoryInfo.AvailableMemory * 0.75); LowMemoryForLinuxDetection = Size.Min(new Size(16, SizeUnit.Megabytes), memoryInfo.AvailableMemory * 0.10); MemoryCacheLimit = GetDefaultMemoryCacheLimit(memoryInfo.TotalPhysicalMemory); AvailableMemoryForRaisingBatchSizeLimit = Size.Min(new Size(768, SizeUnit.Megabytes), memoryInfo.TotalPhysicalMemory / 2); }
public TransactionMergerConfiguration(bool forceUsing32BitsPager) { if (IntPtr.Size == sizeof(int) || forceUsing32BitsPager) { MaxTxSize = new Size(4, SizeUnit.Megabytes); return; } var memoryInfo = MemoryInformation.GetMemoryInfo(); MaxTxSize = Size.Min( new Size(512, SizeUnit.Megabytes), memoryInfo.TotalPhysicalMemory / 10); }
/// <summary> /// This functions queries the different software / hardware records in order to get their properties /// </summary> /// <returns>0 if success and -1 if an exception arises</returns> public int Run() { try { int error = 0; // Gather generic system information PlatformInformation.GetSystemInfo(); // Get specific CPU information GetCPUInfo(); // Get memory information GetMemoryInfo(); // Compute memory parameters MemoryInformation.GetMemoryInfo(System_Memory); #if DEBUG Console.WriteLine(MemoryInformation.ToString()); #endif if (Globals.Enable_File_Output) { Tools.SaveData(Globals.Output_Filename, $"{MemoryInformation.ToString()}\n", true); } // Get video controller information GetVideoControllerInfo(); // Get disk information GetDiskDriveInfo(); // Get disk partitions GetDiskPartitionInfo(); return(error); } catch (Exception ex) { #if DEBUG Console.WriteLine($"Exception Message: {ex.Message}"); #endif return(-1); } }
public void WhenActualSwapSmallerThenMinSwapConfigured_ShouldRaiseNotification() { var memoryInfoResult = MemoryInformation.GetMemoryInfo(); var minSwapConfig = memoryInfoResult.TotalSwapSize + new Sparrow.Size(130, SizeUnit.Megabytes); var customSettings = new Dictionary <string, string> { [RavenConfiguration.GetKey(x => x.PerformanceHints.MinSwapSize)] = minSwapConfig.GetValue(SizeUnit.Megabytes).ToString() }; UseNewLocalServer(customSettings); using var dis = Server.ServerStore.NotificationCenter.GetStored(out var alerts, postponed: false); var alertsList = alerts.ToList(); var isLowSwapSizeRaised = alertsList.Any(a => a.Json[nameof(AlertRaised.AlertType)].ToString() == AlertType.LowSwapSize.ToString()); Assert.True(isLowSwapSizeRaised, $"Actual swap {memoryInfoResult.TotalSwapSize}, min swap config {minSwapConfig}, total memory {memoryInfoResult.TotalPhysicalMemory}"); }
public static MachineResources GetMachineResources(SmapsReader smapsReader, ICpuUsageCalculator cpuUsageCalculator) { var memInfo = MemoryInformation.GetMemoryInfo(smapsReader, extendedInfo: true); var cpuInfo = cpuUsageCalculator.Calculate(); var machineResources = new MachineResources { TotalMemory = memInfo.TotalPhysicalMemory.GetValue(SizeUnit.Bytes), AvailableMemory = memInfo.AvailableMemory.GetValue(SizeUnit.Bytes), AvailableWithoutTotalCleanMemory = memInfo.AvailableWithoutTotalCleanMemory.GetValue(SizeUnit.Bytes), SystemCommitLimit = memInfo.TotalCommittableMemory.GetValue(SizeUnit.Bytes), CommittedMemory = memInfo.CurrentCommitCharge.GetValue(SizeUnit.Bytes), ProcessMemoryUsage = memInfo.WorkingSet.GetValue(SizeUnit.Bytes), IsWindows = PlatformDetails.RunningOnPosix == false, IsLowMemory = LowMemoryNotification.Instance.IsLowMemory(memInfo, smapsReader), LowMemoryThreshold = LowMemoryNotification.Instance.LowMemoryThreshold.GetValue(SizeUnit.Bytes), CommitChargeThreshold = LowMemoryNotification.Instance.GetCommitChargeThreshold(memInfo).GetValue(SizeUnit.Bytes), MachineCpuUsage = cpuInfo.MachineCpuUsage, ProcessCpuUsage = cpuInfo.ProcessCpuUsage }; return(machineResources); }
private static bool CommandInfo(List <string> args, RavenCli cli) { new ClusterMessage(Console.Out, cli._server.ServerStore).Print(); var memoryInfo = MemoryInformation.GetMemoryInfo(); WriteText( $" Build {ServerVersion.Build}, Version {ServerVersion.Version}, SemVer {ServerVersion.FullVersion}, Commit {ServerVersion.CommitHash}" + Environment.NewLine + $" PID {Process.GetCurrentProcess().Id}, {IntPtr.Size * 8} bits, {ProcessorInfo.ProcessorCount} Cores, Arch: {RuntimeInformation.OSArchitecture}" + Environment.NewLine + $" {memoryInfo.TotalPhysicalMemory} Physical Memory, {memoryInfo.AvailableMemory} Available Memory" + Environment.NewLine + $" {RuntimeSettings.Describe()}", ConsoleColor.Cyan, cli); var bitsNum = IntPtr.Size * 8; if (bitsNum == 64 && cli._server.Configuration.Storage.ForceUsing32BitsPager) { WriteText(" Running in 32 bits mode", ConsoleColor.DarkCyan, cli); } return(true); }
public override MemoryInfoResult GetMemoryInfo(bool extended = false) { return(MemoryInformation.GetMemoryInfo(extended ? _smapsReader : null, extended: extended)); }
private static DynamicJsonValue MemoryStatsInternal() { using (var currentProcess = Process.GetCurrentProcess()) { var workingSet = PlatformDetails.RunningOnPosix == false || PlatformDetails.RunningOnMacOsx ? currentProcess.WorkingSet64 : MemoryInformation.GetRssMemoryUsage(currentProcess.Id); var memInfo = MemoryInformation.GetMemoryInfo(); long totalMapping = 0; var fileMappingByDir = new Dictionary <string, Dictionary <string, ConcurrentDictionary <IntPtr, long> > >(); var fileMappingSizesByDir = new Dictionary <string, long>(); foreach (var mapping in NativeMemory.FileMapping) { var dir = Path.GetDirectoryName(mapping.Key); if (fileMappingByDir.TryGetValue(dir, out Dictionary <string, ConcurrentDictionary <IntPtr, long> > value) == false) { value = new Dictionary <string, ConcurrentDictionary <IntPtr, long> >(); fileMappingByDir[dir] = value; } value[mapping.Key] = mapping.Value; foreach (var singleMapping in mapping.Value) { fileMappingSizesByDir.TryGetValue(dir, out long prevSize); fileMappingSizesByDir[dir] = prevSize + singleMapping.Value; totalMapping += singleMapping.Value; } } var prefixLength = LongestCommonPrefixLength(new List <string>(fileMappingSizesByDir.Keys)); var fileMappings = new DynamicJsonArray(); foreach (var sizes in fileMappingSizesByDir.OrderByDescending(x => x.Value)) { if (fileMappingByDir.TryGetValue(sizes.Key, out Dictionary <string, ConcurrentDictionary <IntPtr, long> > value)) { var details = new DynamicJsonValue(); var dir = new DynamicJsonValue { [nameof(MemoryInfoMappingItem.Directory)] = sizes.Key.Substring(prefixLength), [nameof(MemoryInfoMappingItem.TotalDirectorySize)] = sizes.Value, [nameof(MemoryInfoMappingItem.HumaneTotalDirectorySize)] = Size.Humane(sizes.Value), [nameof(MemoryInfoMappingItem.Details)] = details }; foreach (var file in value.OrderBy(x => x.Key)) { long totalMapped = 0; var dja = new DynamicJsonArray(); var dic = new Dictionary <long, long>(); foreach (var mapping in file.Value) { totalMapped += mapping.Value; dic.TryGetValue(mapping.Value, out long prev); dic[mapping.Value] = prev + 1; } foreach (var maps in dic) { dja.Add(new DynamicJsonValue { [nameof(MemoryInfoMappingDetails.Size)] = maps.Key, [nameof(MemoryInfoMappingDetails.Count)] = maps.Value }); } var fileSize = GetFileSize(file.Key); details[Path.GetFileName(file.Key)] = new DynamicJsonValue { [nameof(MemoryInfoMappingFileInfo.FileSize)] = fileSize, [nameof(MemoryInfoMappingFileInfo.HumaneFileSize)] = Size.Humane(fileSize), [nameof(MemoryInfoMappingFileInfo.TotalMapped)] = totalMapped, [nameof(MemoryInfoMappingFileInfo.HumaneTotalMapped)] = Size.Humane(totalMapped), [nameof(MemoryInfoMappingFileInfo.Mappings)] = dja }; } fileMappings.Add(dir); } } long totalUnmanagedAllocations = 0; var threads = new DynamicJsonArray(); foreach (var stats in NativeMemory.ThreadAllocations.Values .Where(x => x.IsThreadAlive()) .GroupBy(x => x.Name) .OrderByDescending(x => x.Sum(y => y.TotalAllocated))) { var unmanagedAllocations = stats.Sum(x => x.TotalAllocated); totalUnmanagedAllocations += unmanagedAllocations; var ids = new DynamicJsonArray(stats.OrderByDescending(x => x.TotalAllocated).Select(x => new DynamicJsonValue { ["Id"] = x.UnmanagedThreadId, ["ManagedThreadId"] = x.Id, ["Allocations"] = x.TotalAllocated, ["HumaneAllocations"] = Size.Humane(x.TotalAllocated) })); var groupStats = new DynamicJsonValue { ["Name"] = stats.Key, ["Allocations"] = unmanagedAllocations, ["HumaneAllocations"] = Size.Humane(unmanagedAllocations) }; if (ids.Count == 1) { var threadStats = stats.First(); groupStats["Id"] = threadStats.UnmanagedThreadId; groupStats["ManagedThreadId"] = threadStats.Id; } else { groupStats["Ids"] = ids; } threads.Add(groupStats); } var managedMemory = GC.GetTotalMemory(false); var djv = new DynamicJsonValue { [nameof(MemoryInfo.WorkingSet)] = workingSet, [nameof(MemoryInfo.TotalUnmanagedAllocations)] = totalUnmanagedAllocations, [nameof(MemoryInfo.ManagedAllocations)] = managedMemory, [nameof(MemoryInfo.TotalMemoryMapped)] = totalMapping, [nameof(MemoryInfo.PhysicalMem)] = Size.Humane(memInfo.TotalPhysicalMemory.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.FreeMem)] = Size.Humane(memInfo.AvailableMemory.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.HighMemLastOneMinute)] = Size.Humane(memInfo.MemoryUsageRecords.High.LastOneMinute.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.LowMemLastOneMinute)] = Size.Humane(memInfo.MemoryUsageRecords.Low.LastOneMinute.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.HighMemLastFiveMinute)] = Size.Humane(memInfo.MemoryUsageRecords.High.LastFiveMinutes.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.LowMemLastFiveMinute)] = Size.Humane(memInfo.MemoryUsageRecords.Low.LastFiveMinutes.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.HighMemSinceStartup)] = Size.Humane(memInfo.MemoryUsageRecords.High.SinceStartup.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.LowMemSinceStartup)] = Size.Humane(memInfo.MemoryUsageRecords.Low.SinceStartup.GetValue(SizeUnit.Bytes)), [nameof(MemoryInfo.Humane)] = new DynamicJsonValue { [nameof(MemoryInfoHumane.WorkingSet)] = Size.Humane(workingSet), [nameof(MemoryInfoHumane.TotalUnmanagedAllocations)] = Size.Humane(totalUnmanagedAllocations), [nameof(MemoryInfoHumane.ManagedAllocations)] = Size.Humane(managedMemory), [nameof(MemoryInfoHumane.TotalMemoryMapped)] = Size.Humane(totalMapping) }, ["Threads"] = threads, [nameof(MemoryInfo.Mappings)] = fileMappings }; return(djv); } }
public static bool TryIncreasingMemoryUsageForThread(NativeMemory.ThreadStats threadStats, ref Size currentMaximumAllowedMemory, bool isRunningOn32Bits, Logger logger, out ProcessMemoryUsage currentUsage) { if (isRunningOn32Bits) { currentUsage = null; return(false); } var currentlyAllocated = new Size(threadStats.TotalAllocated, SizeUnit.Bytes); //TODO: This has to be exposed via debug endpoint // we run out our memory quota, so we need to see if we can increase it or break var memoryInfoResult = MemoryInformation.GetMemoryInfo(); using (var currentProcess = Process.GetCurrentProcess()) { // a lot of the memory that we use is actually from memory mapped files, as such, we can // rely on the OS to page it out (without needing to write, since it is read only in this case) // so we try to calculate how much such memory we can use with this assumption var memoryMappedSize = new Size(currentProcess.WorkingSet64 - currentProcess.PrivateMemorySize64, SizeUnit.Bytes); currentUsage = new ProcessMemoryUsage(currentProcess.WorkingSet64, currentProcess.PrivateMemorySize64); if (memoryMappedSize < Size.Zero) { // in this case, we are likely paging, our working set is smaller than the memory we allocated // it isn't _neccesarily_ a bad thing, we might be paged on allocated memory we aren't using, but // at any rate, we'll ignore that and just use the actual physical memory available memoryMappedSize = Size.Zero; } var minMemoryToLeaveForMemoryMappedFiles = memoryInfoResult.TotalPhysicalMemory / 4; var memoryAssumedFreeOrCheapToFree = (memoryInfoResult.AvailableMemory + memoryMappedSize - minMemoryToLeaveForMemoryMappedFiles); // there isn't enough available memory to try, we want to leave some out for other things if (memoryAssumedFreeOrCheapToFree < memoryInfoResult.TotalPhysicalMemory / 10) { if (logger.IsInfoEnabled) { logger.Info( $"{threadStats.Name} which is already using {currentlyAllocated}/{currentMaximumAllowedMemory} and the system has" + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM. Also have ~{memoryMappedSize} in mmap " + "files that can be cleanly released, not enough to proceed in batch."); } return(false); } // If there isn't enough here to double our current allocation, we won't allocate any more // we do this check in this way to prevent multiple indexes of hitting this at the // same time and each thinking that they have enough space if (memoryAssumedFreeOrCheapToFree < currentMaximumAllowedMemory) { // TODO: We probably need to make a note of this in log & expose in stats // TODO: to explain why we aren't increasing the memory in use if (logger.IsInfoEnabled) { logger.Info( $"{threadStats} which is already using {currentlyAllocated}/{currentMaximumAllowedMemory} and the system has" + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM. Also have ~{memoryMappedSize} in mmap " + "files that can be cleanly released, not enough to proceed in batch."); } return(false); } // even though we have twice as much memory as we have current allocated, we will // only increment by 16MB to avoid over allocation by multiple indexes. This way, // we'll check often as we go along this var oldBudget = currentMaximumAllowedMemory; currentMaximumAllowedMemory = currentlyAllocated + new Size(16, SizeUnit.Megabytes); if (logger.IsInfoEnabled) { logger.Info( $"Increasing memory budget for {threadStats.Name} which is using {currentlyAllocated}/{oldBudget} and the system has" + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM with {memoryMappedSize} in mmap " + $"files that can be cleanly released. Budget increased to {currentMaximumAllowedMemory}"); } return(true); } }
private object CalculateMemoryInfoExtended() { return(MemoryInformation.GetMemoryInfo(_smapsReader, extended: true)); }
private object CalculateMemoryInfo() { return(MemoryInformation.GetMemoryInfo()); }
private static object CalculateMemoryInfo() => MemoryInformation.GetMemoryInfo();
public static bool TryIncreasingMemoryUsageForThread(NativeMemory.ThreadStats threadStats, ref Size currentMaximumAllowedMemory, Size currentlyInUse, bool isRunningOn32Bits, Logger logger, out ProcessMemoryUsage currentUsage) { if (isRunningOn32Bits) { currentUsage = null; return(false); } // we run out our memory quota, so we need to see if we can increase it or break var memoryInfoResult = MemoryInformation.GetMemoryInfo(); using (GetProcessMemoryUsage(out currentUsage, out var mappedSharedMem)) { var memoryAssumedFreeOrCheapToFree = memoryInfoResult.AvailableMemory + mappedSharedMem; // there isn't enough available memory to try, we want to leave some out for other things if (memoryAssumedFreeOrCheapToFree < Size.Min(memoryInfoResult.TotalPhysicalMemory / 50, new Size(1, SizeUnit.Gigabytes))) { if (logger.IsInfoEnabled) { logger.Info( $"{threadStats.Name} which is already using {currentlyInUse}/{currentMaximumAllowedMemory} and the system has " + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM. Also have ~{mappedSharedMem} in mmap " + "files that can be cleanly released, not enough to proceed in batch."); } return(false); } // If there isn't enough here to double our current allocation, we won't allocate any more // we do this check in this way to prevent multiple indexes of hitting this at the // same time and each thinking that they have enough space if (memoryAssumedFreeOrCheapToFree < currentMaximumAllowedMemory) { if (logger.IsInfoEnabled) { logger.Info( $"{threadStats} which is already using {currentlyInUse}/{currentMaximumAllowedMemory} and the system has" + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM. Also have ~{mappedSharedMem} in mmap " + "files that can be cleanly released, not enough to proceed in batch."); } return(false); } // even though we have twice as much memory as we have current allocated, we will // only increment by 16MB to avoid over allocation by multiple indexes. This way, // we'll check often as we go along this var oldBudget = currentMaximumAllowedMemory; currentMaximumAllowedMemory = currentlyInUse + new Size(16, SizeUnit.Megabytes); if (logger.IsInfoEnabled) { logger.Info( $"Increasing memory budget for {threadStats.Name} which is using {currentlyInUse}/{oldBudget} and the system has" + $"{memoryInfoResult.AvailableMemory}/{memoryInfoResult.TotalPhysicalMemory} free RAM with {mappedSharedMem} in mmap " + $"files that can be cleanly released. Budget increased to {currentMaximumAllowedMemory}"); } return(true); } }