/// <summary>
/// Checks out a segment, creating more if the pool is empty.
/// </summary>
/// <returns>a BufferSegment object from the pool</returns>
public BufferSegment CheckOut()
{
BufferSegment segment;
if (!_availableSegments.TryDequeue(out segment))
{
lock (_buffers)
{
while (!_availableSegments.TryDequeue(out segment))
{
CreateBuffer();
}
}
}
// this doubles up with what CheckIn() looks for, but no harm in that, really.
if (segment.m_uses > 1)
{
Console.WriteLine(
string.Format(
"Checked out segment (Size: {0}, Number: {1}) that is already in use! Queue contains: {2}, Buffer amount: {3}",
segment.Length, segment.Number, _availableSegments.Count, _buffers.Count));
}
// set initial usage to 1
segment.m_uses = 1;
return(segment);
}
/// <summary>
/// Checks out a segment, creating more if the pool is empty.
/// </summary>
/// <returns>a BufferSegment object from the pool</returns>
public BufferSegment CheckOut()
{
//log.Info("CheckOut");
BufferSegment segment;
if (!_availableSegments.TryDequeue(out segment))
{
lock (_buffers)
{
while (!_availableSegments.TryDequeue(out segment))
{
CreateBuffer();
}
}
}
// this doubles up with what CheckIn() looks for, but no harm in that, really.
/* if (segment.m_uses > 1)
* {
* log.Error("Checked out segment (Size: {0}, Number: {1}) that is already in use! Queue contains: {2}, Buffer amount: {3}",
* segment.Length, segment.Number, _availableSegments.Count, _buffers.Count);
* }
* if (segment.m_uses < 0)
* {
* log.Error("Checked out segment (Size: {0}, Number: {1}) that is <{4}! Queue contains: {2}, Buffer amount: {3}",
* segment.Length, segment.Number, _availableSegments.Count, _buffers.Count,segment.m_uses);
* }*/
// set initial usage to 1
segment.m_uses = 1;
return(segment);
}
protected virtual void ProcessTasks(long startTime)
{
IMessage message;
while (TaskQueue.TryDequeue(out message))
{
message.Execute();
}
}
/// <summary>
/// Checks out a segment, creating more if the pool is empty.
/// </summary>
/// <returns>a BufferSegment object from the pool</returns>
public BufferSegment CheckOut()
{
BufferSegment bufferSegment;
if (!_availableSegments.TryDequeue(out bufferSegment))
{
lock (_buffers)
{
while (!_availableSegments.TryDequeue(out bufferSegment))
{
CreateBuffer();
}
}
}
bufferSegment.m_uses = 1;
return(bufferSegment);
}
protected virtual void ProcessTasks(long startTime)
{
IMessage msg;
// fire ze tasks
while (TaskQueue.TryDequeue(out msg))
{
msg.Execute();
}
}
/// <summary>
/// Goes through the queue, pulling out clients for the number of slots available at the time.
/// </summary>
/// <param name="state">the timer object</param>
private static void ProcessQueuedClients(object state)
{
var acceptedClients = new List <IRealmClient>();
try
{
var clientAccepts = RealmServerConfiguration.MaxClientCount - RealmServer.Instance.AcceptedClients;
IRealmClient client;
while (clientAccepts != 0)
{
if (s_queuedClients.TryDequeue(out client))
{
acceptedClients.Add(client);
clientAccepts--;
}
else
{
break;
}
}
int clientPosition = 0;
using (var packet = new RealmPacketOut(RealmServerOpCode.SMSG_AUTH_RESPONSE))
{
packet.Write((byte)LoginErrorCode.AUTH_WAIT_QUEUE);
packet.Write(0);
foreach (var waitingClient in s_queuedClients)
{
packet.InsertIntAt(clientPosition++, 5, false);
waitingClient.Send(packet);
}
}
}
catch (Exception e)
{
LogUtil.ErrorException(e, "AuthQueue raised an Exception.");
}
finally
{
PerformanceCounters.NumbersOfClientsInAuthQueue.RawValue = s_queuedClients.Count;
foreach (var acceptedClient in acceptedClients)
{
acceptedClient.Account.IsEnqueued = false;
LoginHandler.InviteToRealm(acceptedClient);
}
}
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
//[TestMethod]
public void TestAll()
{
var num = 5000;
bool done = false;
var q = new LockfreeQueue <int>();
for (int i = 0; i < num; i++)
{
q.Enqueue(i);
}
Assert.AreEqual(num, q.Count);
var values = new int[num];
for (int i = 0; i < num; i++)
{
ThreadPool.QueueUserWorkItem((indexObj) => {
var index = (int)indexObj;
var x = q.TryDequeue();
lock (values)
{
if (index == num - 1)
{
done = true;
Monitor.PulseAll(values);
}
}
}, i);
}
lock (values)
{
if (!done)
{
Monitor.Wait(values);
}
}
var uniqueStrings = new HashSet <int>();
for (int i = 0; i < values.Length; i++)
{
var s = values[i];
Assert.IsNotNull(s);
uniqueStrings.Add(s);
}
Assert.AreEqual(values.Length, uniqueStrings.Count);
}
//
// You can use the following additional attributes as you write your tests:
//
// Use ClassInitialize to run code before running the first test in the class
// [ClassInitialize()]
// public static void MyClassInitialize(TestContext testContext) { }
//
// Use ClassCleanup to run code after all tests in a class have run
// [ClassCleanup()]
// public static void MyClassCleanup() { }
//
// Use TestInitialize to run code before running each test
// [TestInitialize()]
// public void MyTestInitialize() { }
//
// Use TestCleanup to run code after each test has run
// [TestCleanup()]
// public void MyTestCleanup() { }
//
#endregion
//[TestMethod]
public void TestAll()
{
var num = 5000;
bool done = false;
var q = new LockfreeQueue<int>();
for (int i = 0; i < num; i++)
{
q.Enqueue(i);
}
Assert.AreEqual(num, q.Count);
var values = new int[num];
for (int i = 0; i < num; i++)
{
ThreadPool.QueueUserWorkItem((indexObj) => {
var index = (int)indexObj;
var x = q.TryDequeue();
lock (values)
{
if (index == num - 1)
{
done = true;
Monitor.PulseAll(values);
}
}
}, i);
}
lock (values)
{
if (!done)
{
Monitor.Wait(values);
}
}
var uniqueStrings = new HashSet<int>();
for (int i = 0; i < values.Length; i++)
{
var s = values[i];
Assert.IsNotNull(s);
uniqueStrings.Add(s);
}
Assert.AreEqual(values.Length, uniqueStrings.Count);
}
public void TestEnqueueAndDequeue()
{
LockfreeQueue<int> q = new LockfreeQueue<int>();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
// queue count
Assert.AreEqual(3, q.Count);
int value;
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.Dequeue());
Assert.AreEqual(3, q.Dequeue());
Assert.IsFalse(q.TryDequeue(out value));
}
public void TestEnqueueAndDequeue()
{
LockfreeQueue <int> q = new LockfreeQueue <int>();
q.Enqueue(1);
q.Enqueue(2);
q.Enqueue(3);
// queue count
Assert.AreEqual(3, q.Count);
int value;
Assert.AreEqual(1, q.Dequeue());
Assert.AreEqual(2, q.Dequeue());
Assert.AreEqual(3, q.Dequeue());
Assert.IsFalse(q.TryDequeue(out value));
}
/// <summary>
/// Goes through the queue, pulling out clients for the number of slots available at the time.
/// </summary>
/// <param name="state">the timer object</param>
private static void ProcessQueuedClients(object state)
{
List <IRealmClient> realmClientList = new List <IRealmClient>();
try
{
IRealmClient realmClient;
for (int index = RealmServerConfiguration.MaxClientCount -
ServerApp <RealmServer> .Instance.AcceptedClients;
index != 0 && s_queuedClients.TryDequeue(out realmClient);
--index)
{
realmClientList.Add(realmClient);
}
int num = 0;
using (RealmPacketOut packet = new RealmPacketOut(RealmServerOpCode.SMSG_AUTH_RESPONSE))
{
packet.Write((byte)27);
packet.Write(0);
foreach (IRealmClient queuedClient in s_queuedClients)
{
packet.InsertIntAt(num++, 5L, false);
queuedClient.Send(packet, false);
}
}
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "AuthQueue raised an Exception.");
}
finally
{
foreach (IRealmClient client in realmClientList)
{
client.Account.IsEnqueued = false;
LoginHandler.InviteToRealm(client);
}
}
}
protected void QueueUpdateCallback(object state)
{
try
{
if (!_running || Interlocked.CompareExchange(ref _currentUpdateThreadId,
Thread.CurrentThread.ManagedThreadId, 0) != 0)
{
return;
}
long elapsedMilliseconds1 = m_queueTimer.ElapsedMilliseconds;
int dt = (int)(elapsedMilliseconds1 - m_lastUpdate);
m_lastUpdate = (int)elapsedMilliseconds1;
foreach (IUpdatable updatable in m_updatables)
{
try
{
updatable.Update(dt);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to update: " + updatable);
}
}
for (int index = m_timers.Count - 1; index >= 0; --index)
{
SimpleTimerEntry timer = m_timers[index];
if (GetDelayUntilNextExecution(timer) <= 0)
{
try
{
timer.Execute(this);
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to execute timer: " + timer);
}
}
}
IMessage message;
while (m_messageQueue.TryDequeue(out message))
{
try
{
message.Execute();
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to execute message: " + message);
}
if (!_running)
{
return;
}
}
long elapsedMilliseconds2 = m_queueTimer.ElapsedMilliseconds;
long num = elapsedMilliseconds2 - elapsedMilliseconds1 > (long)m_updateInterval
? 0L
: elapsedMilliseconds1 + m_updateInterval - elapsedMilliseconds2;
Interlocked.Exchange(ref _currentUpdateThreadId, 0);
if (_running)
{
_updateTask = Task.Factory.StartNewDelayed((int)num,
QueueUpdateCallback, this);
}
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to run TaskQueue callback for \"{0}\"", (object)Name);
}
}
/// <summary>
/// Collects all update-masks from nearby objects
/// </summary>
internal void UpdateEnvironment(HashSet <WorldObject> updatedObjects)
{
var toRemove = WorldObjectSetPool.Obtain();
toRemove.AddRange(KnownObjects);
toRemove.Remove(this);
NearbyObjects.Clear();
if (m_initialized)
{
Observing.IterateEnvironment(BroadcastRange, (obj) =>
{
if (Client == null || Client.ActiveCharacter == null)
{
if (Client == null)
{
LogUtil.WarnException("Client is null. removeing from map and world? {0}[{1}]", Name, AccId);
}
else
{
if (Client.ActiveCharacter == null)
{
LogUtil.WarnException("Client.ActiveCharacter is null. removeing from map and world? {0}[{1}]", Name, AccId);
}
}
if (Map != null)
{
Map.AddMessage(() =>
{
Map.RemoveObject(this);
World.RemoveCharacter(this);
});
}
return(false);
}
if (!Observing.IsInPhase(obj))
{
return(true);
}
if (obj is GameObject && obj.GetDistance(this) > BroadcastRangeNpc)
{
return(true);
}
NearbyObjects.Add(obj);
//ensure "this" never goes out of range
//if we are observing another units broadcasts
if (!Observing.CanSee(obj) && !ReferenceEquals(obj, this))
{
return(true);
}
if (!KnownObjects.Contains(obj))
{
// encountered new object
//TODO Send upadte Packets here ASDA
var visibleChr = obj as Character;
if (visibleChr != null && visibleChr != this)
{
GlobalHandler.SendCharacterVisibleNowResponse(Client, visibleChr);
if (visibleChr.Asda2Pet != null)
{
GlobalHandler.SendCharacterInfoPetResponse(Client, visibleChr);
}
if (visibleChr.IsAsda2TradeDescriptionEnabled)
{
Asda2PrivateShopHandler.SendtradeStatusTextWindowResponseToOne(
visibleChr, Client);
}
GlobalHandler.SendCharacterPlaceInTitleRatingResponse(Client, visibleChr);
GlobalHandler.SendBuffsOnCharacterInfoResponse(Client, visibleChr);
if (visibleChr.IsInGuild)
{
GlobalHandler.SendCharacterInfoClanNameResponse(Client, visibleChr);
}
GlobalHandler.SendCharacterFactionAndFactionRankResponse(Client, visibleChr);
GlobalHandler.SendCharacterFriendShipResponse(Client, visibleChr);
if (visibleChr.ChatRoom != null)
{
ChatMgr.SendChatRoomVisibleResponse(visibleChr, ChatRoomVisibilityStatus.Visible, visibleChr.ChatRoom, this);
}
CheckAtackStateWithCharacter(visibleChr);
if (visibleChr.Asda2WingsItemId != -1)
{
FunctionalItemsHandler.SendWingsInfoResponse(visibleChr, Client);
}
if (visibleChr.TransformationId != -1)
{
GlobalHandler.SendTransformToPetResponse(visibleChr, true, Client);
}
if (visibleChr.IsOnTransport)
{
FunctionalItemsHandler.SendShopItemUsedResponse(Client, visibleChr, int.MaxValue);
}
if (visibleChr.IsOnMount)
{
Asda2MountHandler.SendCharacterOnMountStatusChangedToPneClientResponse(Client,
visibleChr);
}
}
else
{
var visibleMonstr = obj as NPC;
if (visibleMonstr != null && visibleMonstr.IsAlive)
{
GlobalHandler.SendMonstrVisibleNowResponse(Client, visibleMonstr);
}
else
{
var npc = obj as GameObject;
if (npc != null && npc.GoId != GOEntryId.Portal)
{
if (!IsAsda2BattlegroundInProgress ||
CurrentBattleGround.WarType != Asda2BattlegroundType.Deathmatch ||
MapId != MapId.BatleField)
{
GlobalHandler.SendNpcVisiableNowResponse(Client, npc);
}
}
else
{
var loot = obj as Asda2Loot;
if (loot != null)
{
GlobalHandler.SendItemVisible(this, loot);
}
}
}
}
OnEncountered(obj);
}
toRemove.Remove(obj); // still in range, no need to remove it
return(true);
});
//update group member stats for out of range players
if (m_groupMember != null)
{
m_groupMember.Group.UpdateOutOfRangeMembers(m_groupMember);
}
// delete objects that are not in range anymore
foreach (var obj in toRemove)
{
OnOutOfRange(obj);
}
}
// init player, delete Items etc
Action action;
while (m_environmentQueue.TryDequeue(out action))
{
var ac = action;
// need to Add a message because Update state will be reset after method call
AddMessage(ac);
}
// check rest state
if (m_restTrigger != null)
{
UpdateRestState();
}
toRemove.Clear();
WorldObjectSetPool.Recycle(toRemove);
}
protected void QueueUpdateCallback(object state)
{
try
{
if (!_running)
{
return;
}
if (Interlocked.CompareExchange(ref _currentUpdateThreadId, Thread.CurrentThread.ManagedThreadId, 0) == 0)
{
// get the time at the start of our task processing
var timerStart = m_queueTimer.ElapsedMilliseconds;
var updateDt = (int)(timerStart - m_lastUpdate);
m_lastUpdate = (int)timerStart;
// process updateables
foreach (var updatable in m_updatables)
{
try
{
updatable.Update(updateDt);
}
catch (Exception e)
{
LogUtil.ErrorException(e, "Failed to update: " + updatable);
}
}
// process timers
var count = m_timers.Count;
for (var i = count - 1; i >= 0; i--)
{
var timer = m_timers[i];
if (GetDelayUntilNextExecution(timer) <= 0)
{
try
{
timer.Execute(this);
}
catch (Exception e)
{
LogUtil.ErrorException(e, "Failed to execute timer: " + timer);
}
}
}
// process messages
IMessage msg;
while (m_messageQueue.TryDequeue(out msg))
{
try
{
msg.Execute();
}
catch (Exception e)
{
LogUtil.ErrorException(e, "Failed to execute message: " + msg);
}
if (!_running)
{
return;
}
}
// get the end time
long timerStop = m_queueTimer.ElapsedMilliseconds;
bool updateLagged = timerStop - timerStart > m_updateInterval;
long callbackTimeout = updateLagged ? 0 : ((timerStart + m_updateInterval) - timerStop);
Interlocked.Exchange(ref _currentUpdateThreadId, 0);
if (_running)
{
// re-register the Update-callback
_updateTask = Task.Factory.StartNewDelayed((int)callbackTimeout, QueueUpdateCallback, this);
}
}
}
catch (Exception ex)
{
LogUtil.ErrorException(ex, "Failed to run TaskQueue callback for \"{0}\"", Name);
}
}
/// <summary>
/// Collects all update-masks from nearby objects
/// </summary>
internal void UpdateEnvironment(HashSet <WorldObject> updatedObjects)
{
var toRemove = WorldObjectSetPool.Obtain();
toRemove.AddRange(KnownObjects);
toRemove.Remove(this);
NearbyObjects.Clear();
if (m_initialized)
{
Observing.IterateEnvironment(BroadcastRange, (obj) =>
{
if (!Observing.IsInPhase(obj))
{
return(true);
}
NearbyObjects.Add(obj);
//ensure "this" never goes out of range
//if we are observing another units broadcasts
if (!Observing.CanSee(obj) && !ReferenceEquals(obj, this))
{
return(true);
}
if (!KnownObjects.Contains(obj))
{
// encountered new object
obj.WriteObjectCreationUpdate(this);
OnEncountered(obj);
if (obj.RequiresUpdate)
{
// make sure that it won't send its values next round again
updatedObjects.Add(obj);
}
}
else if (obj.RequiresUpdate)
{
updatedObjects.Add(obj);
obj.WriteObjectValueUpdate(this);
}
toRemove.Remove(obj); // still in range, no need to remove it
return(true);
});
// Update Items
if (m_itemsRequiringUpdates.Count > 0)
{
foreach (var item in m_itemsRequiringUpdates)
{
if (item.m_unknown)
{
// creation update
item.m_unknown = false;
if (m_observers != null && item.IsEquippedItem)
{
foreach (var chr in m_observers)
{
item.WriteObjectCreationUpdate(chr);
}
}
item.WriteObjectCreationUpdate(this);
}
else
{
// value update
if (m_observers != null && item.IsEquippedItem)
{
foreach (var chr in m_observers)
{
item.WriteObjectValueUpdate(chr);
}
}
item.WriteObjectValueUpdate(this);
}
item.ResetUpdateInfo();
}
m_itemsRequiringUpdates.Clear();
}
//update group member stats for out of range players
if (m_groupMember != null)
{
m_groupMember.Group.UpdateOutOfRangeMembers(m_groupMember);
}
// send update packet
if (UpdateCount > 0)
{
SendOwnUpdates();
}
// delete objects that are not in range anymore
foreach (var obj in toRemove)
{
OnOutOfRange(obj);
}
if (toRemove.Count > 0)
{
SendOutOfRangeUpdate(this, toRemove);
}
}
// init player, delete Items etc
Action action;
while (m_environmentQueue.TryDequeue(out action))
{
var ac = action;
// need to Add a message because Update state will be reset after method call
AddMessage(ac);
}
// check rest state
if (m_restTrigger != null)
{
UpdateRestState();
}
toRemove.Clear();
WorldObjectSetPool.Recycle(toRemove);
}
