warrentyexpired/ModernUO
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Targets .NET Core 3.0 (#39)

Browse source
This commit is contained in:
Kamron Batman 2019-08-02 17:53:18 -07:00 • committed by GitHub
parent 0993c03b70
commit 08bf44af9a
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
125 changed files with 1473 additions and 14244 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Server/Persistence/DualSaveStrategy.cs
View file

@ -26,17 +26,17 @@ namespace Server
{
public override string Name => "Dual";
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
public override void Save(bool permitBackgroundWrite)
{
PermitBackgroundWrite = permitBackgroundWrite;
Thread saveThread = new Thread(delegate() { SaveItems(metrics); });
Thread saveThread = new Thread(delegate() { SaveItems(); });
saveThread.Name = "Item Save Subset";
saveThread.Start();
SaveMobiles(metrics);
SaveGuilds(metrics);
SaveMobiles();
SaveGuilds();
saveThread.Join();

23
Server/Persistence/DynamicSaveStrategy.cs
View file

@ -37,7 +37,6 @@ namespace Server
private BlockingCollection<QueuedMemoryWriter> _itemThreadWriters;
private SaveMetrics _metrics;
private SequentialFileWriter _mobileData, _mobileIndex;
private BlockingCollection<QueuedMemoryWriter> _mobileThreadWriters;
@ -51,10 +50,8 @@ namespace Server
public override string Name => "Dynamic";
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
public override void Save(bool permitBackgroundWrite)
{
_metrics = metrics;
OpenFiles();
Task[] saveTasks = new Task[3];
@ -130,8 +127,6 @@ namespace Server
if (item.Decays && item.Parent == null && item.Map != Map.Internal &&
DateTime.UtcNow > item.LastMoved + item.DecayTime) _decayBag.Add(item);
_metrics?.OnItemSaved(size);
return writer;
},
writer =>
@ -165,8 +160,6 @@ namespace Server
writer.QueueForIndex(mobile, size);
_metrics?.OnMobileSaved(size);
return writer;
},
writer =>
@ -201,8 +194,6 @@ namespace Server
writer.QueueForIndex(guild, size);
_metrics?.OnGuildSaved(size);
return writer;
},
writer =>
@ -226,14 +217,14 @@ namespace Server
private void OpenFiles()
{
_itemData = new SequentialFileWriter(World.ItemDataPath, _metrics);
_itemIndex = new SequentialFileWriter(World.ItemIndexPath, _metrics);
_itemData = new SequentialFileWriter(World.ItemDataPath);
_itemIndex = new SequentialFileWriter(World.ItemIndexPath);
_mobileData = new SequentialFileWriter(World.MobileDataPath, _metrics);
_mobileIndex = new SequentialFileWriter(World.MobileIndexPath, _metrics);
_mobileData = new SequentialFileWriter(World.MobileDataPath);
_mobileIndex = new SequentialFileWriter(World.MobileIndexPath);
_guildData = new SequentialFileWriter(World.GuildDataPath, _metrics);
_guildIndex = new SequentialFileWriter(World.GuildIndexPath, _metrics);
_guildData = new SequentialFileWriter(World.GuildDataPath);
_guildIndex = new SequentialFileWriter(World.GuildIndexPath);
WriteCount(_itemIndex, World.Items.Count);
WriteCount(_mobileIndex, World.Mobiles.Count);

15
Server/Persistence/FileQueue.cs
View file

@ -19,9 +19,9 @@
***************************************************************************/
using System;
using System.Buffers;
using System.Collections.Generic;
using System.Threading;
using Server.Network;
namespace Server
{
@ -30,7 +30,6 @@ namespace Server
public sealed class FileQueue : IDisposable
{
private static int bufferSize;
private static BufferPool bufferPool;
private Chunk[] active;
private int activeCount;
@ -47,15 +46,14 @@ namespace Server
static FileQueue()
{
bufferSize = FileOperations.BufferSize;
bufferPool = new BufferPool("File Buffers", 64, bufferSize);
}
public FileQueue(int concurrentWrites, FileCommitCallback callback)
{
if (concurrentWrites < 1) throw new ArgumentOutOfRangeException("concurrentWrites");
if (bufferSize < 1) throw new ArgumentOutOfRangeException("bufferSize");
if (callback == null) throw new ArgumentNullException("callback");
if (bufferSize < 1)
throw new ArgumentOutOfRangeException("bufferSize");
syncRoot = new object();
@ -139,7 +137,7 @@ namespace Server
{
if (active[slot] != chunk) throw new ArgumentException();
bufferPool.ReleaseBuffer(chunk.Buffer);
ArrayPool<byte>.Shared.Return(chunk.Buffer);
if (pending.Count > 0)
{
@ -172,7 +170,8 @@ namespace Server
while (size > 0)
{
if (buffered.buffer == null) buffered.buffer = bufferPool.AcquireBuffer();
if (buffered.buffer == null)
buffered.buffer = ArrayPool<byte>.Shared.Rent(bufferSize);
byte[] page = buffered.buffer; // buffer page
int pageSpace = page.Length - buffered.length; // available bytes in page
@ -229,4 +228,4 @@ namespace Server
public int length;
}
}
}
}

29
Server/Persistence/ParallelSaveStrategy.cs
View file

@ -38,7 +38,6 @@ namespace Server
private SequentialFileWriter itemData, itemIndex;
private SaveMetrics metrics;
private SequentialFileWriter mobileData, mobileIndex;
private int processorCount;
@ -57,10 +56,8 @@ namespace Server
return processorCount - 1;
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
public override void Save(bool permitBackgroundWrite)
{
this.metrics = metrics;
OpenFiles();
consumers = new Consumer[GetThreadCount()];
@ -121,14 +118,14 @@ namespace Server
private void OpenFiles()
{
itemData = new SequentialFileWriter(World.ItemDataPath, metrics);
itemIndex = new SequentialFileWriter(World.ItemIndexPath, metrics);
itemData = new SequentialFileWriter(World.ItemDataPath);
itemIndex = new SequentialFileWriter(World.ItemIndexPath);
mobileData = new SequentialFileWriter(World.MobileDataPath, metrics);
mobileIndex = new SequentialFileWriter(World.MobileIndexPath, metrics);
mobileData = new SequentialFileWriter(World.MobileDataPath);
mobileIndex = new SequentialFileWriter(World.MobileIndexPath);
guildData = new SequentialFileWriter(World.GuildDataPath, metrics);
guildIndex = new SequentialFileWriter(World.GuildIndexPath, metrics);
guildData = new SequentialFileWriter(World.GuildDataPath);
guildIndex = new SequentialFileWriter(World.GuildIndexPath);
WriteCount(itemIndex, World.Items.Count);
WriteCount(mobileIndex, World.Mobiles.Count);
@ -176,9 +173,7 @@ namespace Server
private void Save(Item item, BinaryMemoryWriter writer)
{
int length = writer.CommitTo(itemData, itemIndex, item.m_TypeRef, item.Serial);
metrics?.OnItemSaved(length);
writer.CommitTo(itemData, itemIndex, item.m_TypeRef, item.Serial);
if (item.Decays && item.Parent == null && item.Map != Map.Internal &&
DateTime.UtcNow > item.LastMoved + item.DecayTime) _decayQueue.Enqueue(item);
@ -186,16 +181,12 @@ namespace Server
private void Save(Mobile mob, BinaryMemoryWriter writer)
{
int length = writer.CommitTo(mobileData, mobileIndex, mob.m_TypeRef, mob.Serial);
metrics?.OnMobileSaved(length);
writer.CommitTo(mobileData, mobileIndex, mob.m_TypeRef, mob.Serial);
}
private void Save(BaseGuild guild, BinaryMemoryWriter writer)
{
int length = writer.CommitTo(guildData, guildIndex, 0, guild.Id);
metrics?.OnGuildSaved(length);
writer.CommitTo(guildData, guildIndex, 0, guild.Id);
}
private bool Enqueue(ISerializable value)

138
Server/Persistence/SaveMetrics.cs
View file

@ -1,138 +0,0 @@
/***************************************************************************
* SaveMetrics.cs
* -------------------
* begin : May 1, 2002
* copyright : (C) The RunUO Software Team
* email : info@runuo.com
*
* $Id$
*
***************************************************************************/
/***************************************************************************
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
***************************************************************************/
using System;
using System.Diagnostics;
namespace Server
{
public sealed class SaveMetrics : IDisposable
{
private const string PerformanceCategoryName = "RunUO 2.1";
private const string PerformanceCategoryDesc = "Performance counters for RunUO 2.1.";
private bool isDisposed;
private PerformanceCounter itemsPerSecond;
private PerformanceCounter mobilesPerSecond;
private PerformanceCounter numberOfWorldSaves;
private PerformanceCounter serializedBytesPerSecond;
private PerformanceCounter writtenBytesPerSecond;
public SaveMetrics()
{
if (!PerformanceCounterCategory.Exists(PerformanceCategoryName))
{
CounterCreationDataCollection counters = new CounterCreationDataCollection();
counters.Add(new CounterCreationData(
"Save - Count",
"Number of world saves.",
PerformanceCounterType.NumberOfItems32
)
);
counters.Add(new CounterCreationData(
"Save - Items/sec",
"Number of items saved per second.",
PerformanceCounterType.RateOfCountsPerSecond32
)
);
counters.Add(new CounterCreationData(
"Save - Mobiles/sec",
"Number of mobiles saved per second.",
PerformanceCounterType.RateOfCountsPerSecond32
)
);
counters.Add(new CounterCreationData(
"Save - Serialized bytes/sec",
"Amount of world-save bytes serialized per second.",
PerformanceCounterType.RateOfCountsPerSecond32
)
);
counters.Add(new CounterCreationData(
"Save - Written bytes/sec",
"Amount of world-save bytes written to disk per second.",
PerformanceCounterType.RateOfCountsPerSecond32
)
);
PerformanceCounterCategory.Create(PerformanceCategoryName, PerformanceCategoryDesc,
PerformanceCounterCategoryType.SingleInstance, counters);
}
numberOfWorldSaves = new PerformanceCounter(PerformanceCategoryName, "Save - Count", false);
itemsPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Items/sec", false);
mobilesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Mobiles/sec", false);
serializedBytesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Serialized bytes/sec", false);
writtenBytesPerSecond = new PerformanceCounter(PerformanceCategoryName, "Save - Written bytes/sec", false);
// increment number of world saves
numberOfWorldSaves.Increment();
}
public void Dispose()
{
if (!isDisposed)
{
isDisposed = true;
numberOfWorldSaves.Dispose();
itemsPerSecond.Dispose();
mobilesPerSecond.Dispose();
serializedBytesPerSecond.Dispose();
writtenBytesPerSecond.Dispose();
}
}
public void OnItemSaved(int numberOfBytes)
{
itemsPerSecond.Increment();
serializedBytesPerSecond.IncrementBy(numberOfBytes);
}
public void OnMobileSaved(int numberOfBytes)
{
mobilesPerSecond.Increment();
serializedBytesPerSecond.IncrementBy(numberOfBytes);
}
public void OnGuildSaved(int numberOfBytes)
{
serializedBytesPerSecond.IncrementBy(numberOfBytes);
}
public void OnFileWritten(int numberOfBytes)
{
writtenBytesPerSecond.IncrementBy(numberOfBytes);
}
}
}

2
Server/Persistence/SaveStrategy.cs
View file

@ -40,7 +40,7 @@ namespace Server
return new StandardSaveStrategy();
}
public abstract void Save(SaveMetrics metrics, bool permitBackgroundWrite);
public abstract void Save(bool permitBackgroundWrite);
public abstract void ProcessDecay();
}

10
Server/Persistence/SequentialFileWriter.cs
View file

@ -28,16 +28,12 @@ namespace Server
private FileQueue fileQueue;
private FileStream fileStream;
private SaveMetrics metrics;
private AsyncCallback writeCallback;
public SequentialFileWriter(string path, SaveMetrics metrics)
public SequentialFileWriter(string path)
{
if (path == null) throw new ArgumentNullException("path");
this.metrics = metrics;
fileStream = FileOperations.OpenSequentialStream(path, FileMode.Create, FileAccess.Write, FileShare.None);
fileQueue = new FileQueue(
@ -66,8 +62,6 @@ namespace Server
{
fileStream.Write(chunk.Buffer, chunk.Offset, chunk.Size);
metrics?.OnFileWritten(chunk.Size);
chunk.Commit();
}
else
@ -84,8 +78,6 @@ namespace Server
fileStream.EndWrite(asyncResult);
metrics?.OnFileWritten(chunk.Size);
chunk.Commit();
}

20
Server/Persistence/StandardSaveStrategy.cs
View file

@ -47,20 +47,20 @@ namespace Server
protected bool UseSequentialWriters => SaveType == SaveOption.Normal || !PermitBackgroundWrite;
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
public override void Save(bool permitBackgroundWrite)
{
PermitBackgroundWrite = permitBackgroundWrite;
SaveMobiles(metrics);
SaveItems(metrics);
SaveGuilds(metrics);
SaveMobiles();
SaveItems();
SaveGuilds();
if (permitBackgroundWrite && UseSequentialWriters
) //If we're permitted to write in the background, but we don't anyways, then notify.
World.NotifyDiskWriteComplete();
}
protected void SaveMobiles(SaveMetrics metrics)
protected void SaveMobiles()
{
Dictionary<Serial, Mobile> mobiles = World.Mobiles;
@ -92,8 +92,6 @@ namespace Server
m.Serialize(bin);
metrics?.OnMobileSaved((int)(bin.Position - start));
idx.Write((int)(bin.Position - start));
m.FreeCache();
@ -109,7 +107,7 @@ namespace Server
bin.Close();
}
protected void SaveItems(SaveMetrics metrics)
protected void SaveItems()
{
Dictionary<Serial, Item> items = World.Items;
@ -147,8 +145,6 @@ namespace Server
item.Serialize(bin);
metrics?.OnItemSaved((int)(bin.Position - start));
idx.Write((int)(bin.Position - start));
item.FreeCache();
@ -163,7 +159,7 @@ namespace Server
bin.Close();
}
protected void SaveGuilds(SaveMetrics metrics)
protected void SaveGuilds()
{
GenericWriter idx;
GenericWriter bin;
@ -190,8 +186,6 @@ namespace Server
guild.Serialize(bin);
metrics?.OnGuildSaved((int)(bin.Position - start));
idx.Write((int)(bin.Position - start));
}