public static void DisposingTheSharedPoolIsANop()
{
MemoryPool <int> mp = MemoryPool <int> .Shared;
mp.Dispose();
mp.Dispose();
using (IMemoryOwner <int> block = mp.Rent(10))
{
Assert.True(block.Memory.Length >= 10);
}
}
void OnApplicationQuit()
{
bloodParticlePool.Dispose();
bulletHolePool.Dispose();
flarePool.Dispose();
bulletCasingPool.Dispose();
}
public void MemoryPoolBlockReferenceTests()
{
var pool = new MemoryPool();
BufferReferenceTests.TestOwnedBuffer(() => pool.Rent(1024), block => pool.Return((MemoryPoolBlock)block));
pool.Dispose();
}
public static void Run(int numberOfRequests, int concurrentConnections, byte[] requestPayload, Action <object, WritableBuffer> writeResponse)
{
var memoryPool = new MemoryPool();
var listener = new FakeListener(memoryPool, concurrentConnections);
listener.OnConnection(async connection => {
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
ReadableBuffer input = result.Buffer;
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
var requestBytes = input.First;
if (requestBytes.Length != 492)
{
continue;
}
// Parse the input http request
// TODO: use the Kestrel parser here
object parsedRequest = null;
// Writing directly to pooled buffers
var output = connection.Output.Alloc();
writeResponse(parsedRequest, output);
await output.FlushAsync();
}
catch (Exception e)
{
var istr = new Utf8Span(input.First.Span).ToString();
Debug.WriteLine(e.Message);
}
finally
{
// Consume the input
connection.Input.Advance(input.End, input.End);
}
}
});
var tasks = new Task[numberOfRequests];
for (int i = 0; i < numberOfRequests; i++)
{
tasks[i] = listener.ExecuteRequestAsync(requestPayload);
}
Task.WaitAll(tasks);
listener.Dispose();
memoryPool.Dispose();
}
public void Dispose()
{
Transport.Input.Complete();
Transport.Output.Complete();
MemoryPool.Dispose();
}
// When application quit, Memory clear
void OnApplicationQuit()
{
MPool1.Dispose();
MPool2.Dispose();
MPool3.Dispose();
MPool4.Dispose();
}
protected override void Dispose(bool disposing)
{
if (disposing)
{
_memoryPool.Dispose();
}
}
public void Cleanup()
{
_pair.Application.Input.Complete();
_pair.Application.Output.Complete();
_pair.Transport.Input.Complete();
_pair.Transport.Output.Complete();
_memoryPool.Dispose();
}
// 게임이 종료되면 자동으로 호출되는 함수
private void OnApplicationQuit()
{
// 메모리 풀을 비웁니다.
if (MPool != null)
{
MPool.Dispose();
}
}
public void Dispose()
{
GC.Collect(); GC.Collect();
GC.WaitForPendingFinalizers();
_pipe.Writer.Complete();
_pipe.Reader.Complete();
_pool?.Dispose();
}
public async ValueTask DisposeAsync()
{
await _host.StopAsync().ConfigureAwait(false);
// The concrete Host implements IAsyncDisposable
await((IAsyncDisposable)_host).DisposeAsync().ConfigureAwait(false);
_memoryPool.Dispose();
}
public void Dispose()
{
Application.Input.Complete();
Application.Output.Complete();
Transport.Input.Complete();
Transport.Output.Complete();
_memoryPool.Dispose();
}
private void UnloadScene()
{
GameManager.instance.mainBGM.Play();
GameManager.instance.Player.SetActive(true);
Debug.Log("UnloadScene Call!");
StonePool.Dispose();
ParticlePool.Dispose();
SceneManager.UnloadSceneAsync(SceneManager.GetSceneByName("MouseClickGame"));
}
void OnDisable()
{
ClearColliders(true);
if (pool != null)
{
pool.Dispose();
pool = null;
}
}
public static void RunSingleSegmentParser(int numberOfRequests, int concurrentConnections, byte[] requestPayload, WriteResponseDelegate writeResponse)
{
var memoryPool = new MemoryPool();
var listener = new FakeListener(new MemoryPool(), concurrentConnections);
listener.OnConnection(async connection =>
{
while (true)
{
// Wait for data
var result = await connection.Input.ReadAsync();
ReadableBuffer input = result.Buffer;
try
{
if (input.IsEmpty && result.IsCompleted)
{
// No more data
break;
}
var requestBuffer = input.First;
if (requestBuffer.Length != 492)
{
continue;
}
// Parse the input http request
WritableBuffer output = WriteResponse(writeResponse, connection, requestBuffer);
await output.FlushAsync();
}
catch (Exception e)
{
var istr = new Utf8String(input.First.Span).ToString();
Debug.WriteLine(e.Message);
}
finally
{
// Consume the input
connection.Input.Advance(input.End, input.End);
}
}
});
var tasks = new Task[numberOfRequests];
for (int i = 0; i < numberOfRequests; i++)
{
tasks[i] = listener.ExecuteRequestAsync(requestPayload);
}
Task.WaitAll(tasks);
listener.Dispose();
memoryPool.Dispose();
}
public override void Dispose()
{
_pair.Application.Input.Complete();
_pair.Application.Output.Complete();
_pair.Transport.Input.Complete();
_pair.Transport.Output.Complete();
_memoryPool.Dispose();
base.Dispose();
}
public void Dispose()
{
_transport.Input.Complete();
_transport.Output.Complete();
_application.Input.Complete();
_application.Output.Complete();
_pipelineFactory.Dispose();
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_connection?.Dispose();
WriterPool?.Dispose();
}
public void Dispose()
{
if (!_disposed)
{
_disposed = true;
// This is a no-op for MemoryPool.Shared
// See https://github.com/dotnet/corefx/blob/master/src/System.Memory/src/System/Buffers/ArrayMemoryPool.cs
_pool.Dispose();
}
}
public void Dispose()
{
Assert.Empty(this.PeerManager.ChannelManager.GetAndClearPendingEvents(_pool));
var networkGraph = this.PeerManager.GetNetworkGraph(_pool);
var peerMan = PeerManager.Create(NodeConfig.NodeSeed.ToBytes(), _testUserConfigProvider, NodeConfig.ChainMonitor, NodeConfig.TestLogger, NodeConfig.KeysManager.GetNodeSecret().ToBytes(), ChannelManager, BlockNotifier, 30000, networkGraph);
Assert.Equal(networkGraph, peerMan.GetNetworkGraph(_pool));
_pool.Dispose();
PeerManager.Dispose();
}
void IDisposable.Dispose()
{
base.Dispose();
_transport.Input.Complete();
_transport.Output.Complete();
_application.Input.Complete();
_application.Output.Complete();
_pipelineFactory.Dispose();
}
public void Dispose()
{
if (_disposed)
{
return;
}
_disposed = true;
_connection?.Dispose();
WriterPool?.Dispose();
GC.SuppressFinalize(this);
}
/// <summary>
/// Releases all resources owned by the listener
/// </summary>
protected virtual void Dispose(bool disposing)
{
if (disposing)
{
GC.SuppressFinalize(this);
_socket?.Dispose();
_socket = null;
if (_ownsPool)
{
_pool?.Dispose();
}
_pool = null;
}
}
private void DisposeAllPool()
{
foreach (var pool in EnemyWavePool)
{
//pool.AllDespawn();
pool.Dispose();
}
foreach (var pool in GamePlayerMove.instance.throwObjectPool)
{
//pool.AllDespawn();
pool.Dispose();
}
ParticlePool.Dispose();
}
void MemoryPoolDelete()
{
if (memoryPoolRight != null)
{
memoryPoolRight.Dispose();
}
if (memoryPoolLeft != null)
{
memoryPoolLeft.Dispose();
}
if (memoryPoolEffect != null)
{
memoryPoolEffect.Dispose();
}
if (LeftNote != null)
{
foreach (var o in LeftNote)
{
if (o != null)
{
Destroy(o);
}
}
}
if (RightNote != null)
{
foreach (var o in RightNote)
{
if (o != null)
{
Destroy(o);
}
}
}
if (Effect != null)
{
foreach (var o in Effect)
{
if (o != null)
{
Destroy(o);
}
}
}
}
void MemoryPoolDelete()
{
memoryPoolRight.Dispose();
memoryPoolLeft.Dispose();
memoryPoolEffect.Dispose();
foreach (var o in LeftNote)
{
Destroy(o);
}
foreach (var o in RightNote)
{
Destroy(o);
}
foreach (var o in Effect)
{
Destroy(o);
}
}
public async Task DisposeAsync()
{
if (!_disposed)
{
_disposed = true;
_stopping = true;
_output.Reader.CancelPendingRead();
await Task.WhenAll(_sendTask, _receiveTask);
_output.Writer.Complete();
_input.Reader.Complete();
_socket?.Dispose();
_socket = null;
if (_ownsPool)
{
_pool?.Dispose();
}
_pool = null;
}
}
public void Close()
{
_allDone.WaitOne();
_isStart = false;
if (_useIOEvents != null)
{
try
{
Monitor.Enter(_useIOEvents);
foreach (var c in _useIOEvents)
{
(c.Value.UserToken as StateObject).Dispose();
c.Value.Dispose();
}
}
finally
{
Monitor.Exit(_useIOEvents);
}
}
_ioEventPool.Dispose();
Close();
_useIOEvents = null;
}
protected override void Dispose(bool disposing)
{
if (IsDisposed)
{
MemoryPoolThrowHelper.ThrowInvalidOperationException_DoubleDispose();
}
bool allBlocksReturned = false;
try
{
lock (_syncObj)
{
IsDisposed = true;
allBlocksReturned = _blocks.Count == 0;
if (!allBlocksReturned && !_allowLateReturn)
{
MemoryPoolThrowHelper.ThrowInvalidOperationException_DisposingPoolWithActiveBlocks(_totalBlocks - _blocks.Count, _totalBlocks, _blocks.ToArray());
}
if (_blockAccessExceptions.Count > 0)
{
throw CreateAccessExceptions();
}
}
}
finally
{
if (allBlocksReturned)
{
SetAllBlocksReturned();
}
_pool.Dispose();
}
}
public void ServerPipeListenForConnections()
{
const string pipeName = @"\\.\pipe\ServerPipeListenForConnections";
var loop = new UvLoopHandle(_logger);
var serverListenPipe = new UvPipeHandle(_logger);
loop.Init(_uv);
serverListenPipe.Init(loop, (a, b) => { }, false);
serverListenPipe.Bind(pipeName);
serverListenPipe.Listen(128, (backlog, status, error, state) =>
{
var serverConnectionPipe = new UvPipeHandle(_logger);
serverConnectionPipe.Init(loop, (a, b) => { }, true);
try
{
serverListenPipe.Accept(serverConnectionPipe);
}
catch (Exception)
{
serverConnectionPipe.Dispose();
return;
}
var writeRequest = new UvWriteReq(new KestrelTrace(new TestKestrelTrace()));
writeRequest.Init(loop);
var pool = new MemoryPool();
var block = pool.Lease();
block.GetIterator().CopyFrom(new ArraySegment <byte>(new byte[] { 1, 2, 3, 4 }));
var start = new MemoryPoolIterator(block, 0);
var end = new MemoryPoolIterator(block, block.Data.Count);
writeRequest.Write(
serverConnectionPipe,
start,
end,
1,
(handle, status2, error2, state2) =>
{
writeRequest.Dispose();
serverConnectionPipe.Dispose();
serverListenPipe.Dispose();
pool.Return(block);
pool.Dispose();
},
null);
}, null);
var worker = new Thread(() =>
{
var loop2 = new UvLoopHandle(_logger);
var clientConnectionPipe = new UvPipeHandle(_logger);
var connect = new UvConnectRequest(new KestrelTrace(new TestKestrelTrace()));
loop2.Init(_uv);
clientConnectionPipe.Init(loop2, (a, b) => { }, true);
connect.Init(loop2);
connect.Connect(clientConnectionPipe, pipeName, (handle, status, error, state) =>
{
var buf = loop2.Libuv.buf_init(Marshal.AllocHGlobal(8192), 8192);
connect.Dispose();
clientConnectionPipe.ReadStart(
(handle2, cb, state2) => buf,
(handle2, status2, state2) =>
{
if (status2 == Constants.EOF)
{
clientConnectionPipe.Dispose();
}
},
null);
}, null);
loop2.Run();
loop2.Dispose();
});
worker.Start();
loop.Run();
loop.Dispose();
worker.Join();
}
