internal HeaderTable SetMaxLength(int maxLength, IBufferPool pool) { if (checked ((int)maxLength) == MaxLength) { return(this); } if (maxLength == 0 || Count == 0) { _buffer?.Dispose(); return(new HeaderTable(maxLength ^ DefaultMaxLength, 0, null)); } int bytesToKeep = 0, headersToKeep = 0, totalBytes = 0; var span = _buffer.Data.Span; for (int i = 0; i < Count; i++) { long lengths = span.Slice(bytesToKeep).Read <long>(); int itemLen = ItemLength(lengths); totalBytes += itemLen; if (totalBytes > MaxLength) { break; } bytesToKeep += itemLen; headersToKeep++; } var newBuffer = pool.Lease(maxLength); _buffer.Data.Span.Slice(0, bytesToKeep).CopyTo(newBuffer.Data.Span.Slice(bytesToKeep)); _buffer.Dispose(); return(new HeaderTable(maxLength ^ DefaultMaxLength, headersToKeep, newBuffer)); }
/// <summary> /// Completes an asynchronous send /// </summary> /// <param name="ar">AsyncResul obtained from BeginSend</param> private void CompleteSend(IAsyncResult ar) { // Complete asynchronous send IBuffer sendBuffer = (IBuffer)ar.AsyncState; try { if (!socket.Connected) { return; } lock (syncSocket) { socket.EndSend(ar); } sendBuffer.Dispose(); sendBuffer = null; } catch (Exception ex) { Diags.LogSocketException(ex); if (sendBuffer != null) { sendBuffer.Dispose(); sendBuffer = null; } } }
/// <summary> /// Begins an asynchronous receive /// </summary> /// <param name="Buffer">Buffer to store received data</param> /// <param name="ReadCallBack">Method to call on receiving data</param> /// <param name="StateObject">State object to be passed to ReadCallBack</param> /// <returns>AsyncResult for the asynchronous operation</returns> public IAsyncResult BeginReceive(int BufferLength, AsyncCallback ReadCallBack, object StateObject) { try { if (recvBuffer == null || recvBuffer.IsDisposed) { recvBuffer = bufferPool.GetBuffer(BufferLength); } else if (recvBuffer.Size < BufferLength) { recvBuffer.Dispose(); recvBuffer = bufferPool.GetBuffer(BufferLength); } lock (syncSocket) { return(socket.BeginReceive(recvBuffer.GetSegments(), SocketFlags.None, ReadCallBack, StateObject)); } } catch (Exception ex) { Diags.LogSocketException(ex); return(null); } }
private IBuffer GetGlBuffer(ref IBuffer glBuffer, BufferTarget target, int offset) { if (!dirty) { return(glBuffer); } var nonDynamic = rawDataResource.Volatility != ResourceVolatility.Volatile; var resourcePtr = rawDataResource.Map(); var resourceOffsetPtr = resourcePtr + offset; var glBufferSize = rawDataResource.Size - offset; if (glBuffer == null || glBuffer.SizeInBytes != glBufferSize) { glBuffer?.Dispose(); var usage = nonDynamic ? BufferUsageHint.StaticDraw : BufferUsageHint.DynamicDraw; // todo: target for index buffer glBuffer = infra.GlContext.Create.Buffer(target, glBufferSize, usage, resourceOffsetPtr); } else if (nonDynamic) { glBuffer.SetData(resourceOffsetPtr); } else { var bufferPtr = glBuffer.Map(0, glBufferSize, MapAccess.Write | MapAccess.InvalidateBuffer); PtrHelper.CopyBulk((byte *)bufferPtr, (byte *)resourceOffsetPtr, glBufferSize); glBuffer.Unmap(); } rawDataResource.Unmap(false); dirty = false; return(glBuffer); }
/// <summary> /// Sends data via the socket asynchronously /// </summary> /// <param name="Message">Data to transmit</param> public void Send(ResponseData Message) { IBuffer sendBuffer = null; //TODO: ENHANCEMENT: Log consecutive bad request response types and use that information to disconnect socket after 3 try { lock (syncSocket) { if (sentMsgs.Count > 1) { sentMsgs.Dequeue(); } sentMsgs.Enqueue(Message); //Log error if .Data is null -- this will help raise a flag if the message is being resent after .ClearData was called Diags.Assert(Message.Data != null, "ASSERTION FAILED: Message Data is null", new System.Diagnostics.StackTrace().ToString()); sendBuffer = bufferPool.GetBuffer(Message.Data.LongLength); sendBuffer.CopyFrom(Message.Data); socket.BeginSend(sendBuffer.GetSegments(), SocketFlags.None, CompleteSend, sendBuffer); Message.ClearData(); //free some memory } } catch (Exception ex) { Diags.LogSocketException(ex); if (sendBuffer != null) { sendBuffer.Dispose(); sendBuffer = null; } } }
void IDisposable.Dispose() { textureVariable?.Dispose(); bindings?.Dispose(); pipelineState?.Dispose(); constantBuffer?.Dispose(); }
public void TestWrite() { LosgapSystem.InvokeOnMaster(() => { // Define variables and constants IBuffer res = BufferFactory.NewBuffer <int>() .WithUsage(ResourceUsage.Write) .WithLength(100) .Create(); IBuffer copyDest = (res as Buffer <int>).Clone() .WithUsage(ResourceUsage.StagingRead) .WithPermittedBindings(GPUBindings.None) .Create(); // Set up context // Execute Assert.IsTrue(res.CanWrite); res.Write(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }, 10U); res.CopyTo(copyDest); // Assert outcome byte[] readData = copyDest.Read(); for (int i = 10; i < 20; ++i) { Assert.AreEqual(i - 9, readData[i]); } res.Dispose(); copyDest.Dispose(); }); }
internal static void Share() { IEnumerable <int> sequence = Enumerable.Range(0, 5); IEnumerator <int> independentIterator1 = sequence.GetEnumerator(); IEnumerator <int> independentIterator2 = sequence.GetEnumerator(); independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 0| | independentIterator2.MoveNext(); independentIterator2.Current.WriteLine(); // |0| independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 1| | IEnumerator <int> independentIterator3 = sequence.GetEnumerator(); // | | independentIterator3.MoveNext(); independentIterator3.Current.WriteLine(); // | |0 independentIterator1.MoveNext(); independentIterator1.Current.WriteLine(); // 2| | independentIterator2.MoveNext(); independentIterator2.Current.WriteLine(); // |1| // ... IBuffer <int> share = Enumerable.Range(0, 5).Share(); IEnumerator <int> sharedIterator1 = share.GetEnumerator(); IEnumerator <int> sharedIterator2 = share.GetEnumerator(); sharedIterator1.MoveNext(); sharedIterator1.Current.WriteLine(); // 0| | sharedIterator2.MoveNext(); sharedIterator2.Current.WriteLine(); // |1| sharedIterator1.MoveNext(); sharedIterator1.Current.WriteLine(); // 2| | IEnumerator <int> sharedIterator3 = share.GetEnumerator(); // | | sharedIterator3.MoveNext(); sharedIterator3.Current.WriteLine(); // | |3 share.Dispose(); sharedIterator1.MoveNext(); // ObjectDisposedException. sharedIterator2.MoveNext(); // ObjectDisposedException. sharedIterator3.MoveNext(); // ObjectDisposedException. }
public void BufferIsReusedAfterDispose() { subject = new CachingBufferManager(options); IBuffer buffer1 = subject.GetBuffer(2049); buffer1.Dispose(); IBuffer buffer2 = subject.GetBuffer(2050); Assert.AreSame(buffer1, buffer2); }
void IDisposable.Dispose() { textureVariableRgb?.Dispose(); bindingsRgb?.Dispose(); psoRgb?.Dispose(); textureVariableInvert?.Dispose(); bindingsInvert?.Dispose(); psoInvert?.Dispose(); constantBuffer?.Dispose(); }
public void Push(IBuffer item) { if (_availableCount > _initialCount) { Interlocked.Decrement(ref _totalCount); item.Dispose(); } else { PushBuffer(item); } }
public void TryFreeSlabTest() { long SlabSize = BufferPool.MinimumSlabSize; int InitialSlabs = 1; int SubsequentSlabs = 3; BufferPool target = new BufferPool(SlabSize, InitialSlabs, SubsequentSlabs); Assert.AreEqual <long>(InitialSlabs, target.SlabCount); //GetBuffer of slab size IBuffer buff1 = target.GetBuffer(SlabSize); //confirm that slabcount is 1 Assert.AreEqual <long>(InitialSlabs, target.SlabCount); //Try to free a slab and do a recount -- slabcount should remain 1 target.TryFreeSlab(); Assert.AreEqual <long>(InitialSlabs, target.SlabCount); //Get it again to force construction of 3 new slabs IBuffer buff2 = target.GetBuffer(SlabSize); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs, target.SlabCount); //Free a slab and do a recount target.TryFreeSlab(); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs - 1, target.SlabCount); //Free a slab and do a recount -- slabcount should not budge since only one slab is free target.TryFreeSlab(); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs - 1, target.SlabCount); //Try to free a slab and do a recount //Free 1st buffer buff1.Dispose(); target.TryFreeSlab(); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs - 2, target.SlabCount); //Try to free a slab and do a recount -- slabcount shouldn't go below two target.TryFreeSlab(); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs - 2, target.SlabCount); //Free buffer, try to free a slab and do a recount -- slabcount should now be back to 1 buff2.Dispose(); target.TryFreeSlab(); Assert.AreEqual <long>(SubsequentSlabs + InitialSlabs - 3, target.SlabCount); }
public unsafe IVertexArray GetVao() { if (!isDirty && NumPoints == lastPointCount) { return(vao); } if (aspect.VisualBorderCurve == null || aspect.VisualBorderCurve.Count == 0) { return(null); } if (vao == null) { vao = glContext.Create.VertexArray(); } var newPointCount = NumPoints; if (vertexBuffer == null || bufferPointCapacity < newPointCount) { vertexBuffer?.Dispose(); while (bufferPointCapacity < newPointCount) { bufferPointCapacity *= 2; } vertexBuffer = glContext.Create.Buffer(BufferTarget.Array, bufferPointCapacity * sizeof(Vector4), BufferUsageHint.DynamicDraw); vao.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Four, VertexAttribPointerType.Float, false, sizeof(Vector4), 0); } var rawData = aspect.BorderComplete ? aspect.VisualBorderCurve.Concat(aspect.VisualBorderCurve.First().EnumSelf()).Select(xy => new Vector4(xy, 0, 1)).ToArray() : aspect.VisualBorderCurve.Select(xy => new Vector4(xy, 0, 1)).ToArray(); var sizeInBytes = rawData.Length * sizeof(Vector4); var dst = vertexBuffer.Map(0, vertexBuffer.SizeInBytes, MapAccess.Write | MapAccess.InvalidateBuffer); fixed(Vector4 *src = rawData) PtrHelper.CopyBulk((byte *)dst, (byte *)src, sizeInBytes); vertexBuffer.Unmap(); lastPointCount = newPointCount; isDirty = false; return(vao); }
private async Task <ReadFileResult> ReadFile(int length) { IBuffer content = bufferAllocator.Allocate(length); Stream dest = content.GetStream(); IMD5HashProvider chunkHash = MD5HashProviderFactory.GetHashProvider().CreateHash(); byte[] b = ArrayPool <byte> .Shared.Rent(Configuration.BufferSize); try { int read = 0; int toRead = length; do { read = await fileStream.ReadAsync(b, offset : 0, count : Math.Min(b.Length, toRead)).ConfigureAwait(false); toRead -= read; await dest.WriteAsync(b, offset : 0, count : read).ConfigureAwait(false); chunkHash.Append(b, offset: 0, size: read); fileHash.Append(b, offset: 0, size: read); } while (read > 0 && toRead > 0); if (toRead > 0) { throw new Exception($"Expected to read {length} bytes, actual read {length - toRead} bytes"); } chunkHash.Finalize(ArrayPool <byte> .Shared.Rent(0), 0, 0); return(new ReadFileResult { Content = content, Hash = chunkHash.GetComputedHashAsString() }); } catch { content.Dispose(); throw; } finally { ArrayPool <byte> .Shared.Return(b); dest.Dispose(); } }
public void UseBiggerActionReusingExisting() { options.MaxBuffersPerSizeBand = 2; options.ActionOnBufferUnavailable = CachingBufferManager.Options.BufferUnavailableAction.UseBigger; subject = new CachingBufferManager(options); // This buffer will be used later on IBuffer bigger = subject.GetBuffer(4098); bigger.Dispose(); IBuffer buffer1 = subject.GetBuffer(3000); IBuffer buffer2 = subject.GetBuffer(3000); IBuffer buffer3 = subject.GetBuffer(3000); Assert.AreSame(bigger, buffer3); }
internal static void Publish2() { IBuffer <int> publish = Enumerable.Range(0, 5).Publish(); IEnumerator <int> iterator1 = publish.GetEnumerator(); // iterator1: 0 1 2 3 4 IEnumerator <int> iterator2 = publish.GetEnumerator(); // iterator1: 0 1 2 3 4 iterator1.MoveNext(); iterator1.Current.WriteLine(); // 0| |Trace: 0 iterator1.MoveNext(); iterator1.Current.WriteLine(); // 1| |Trace: 1 iterator1.MoveNext(); iterator1.Current.WriteLine(); // 2| |Trace: 2 iterator2.MoveNext(); iterator2.Current.WriteLine(); // |0| iterator1.MoveNext(); iterator1.Current.WriteLine(); // 3| |Trace: 3 iterator2.MoveNext(); iterator2.Current.WriteLine(); // |1| iterator1.MoveNext(); iterator1.Current.WriteLine(); // 4| |Trace: 4 publish.Dispose(); iterator1.MoveNext(); // ObjectDisposedException. iterator2.MoveNext(); // ObjectDisposedException. }
internal static void Publish() { IBuffer <int> publish = TracedRange(0, 5).Publish(); IEnumerator <int> iterator1 = publish.GetEnumerator(); // iterator1: 0 1 2 3 4 iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 0| |Trace: 0 iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 1| |Trace: 1 iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 2| |Trace: 2 IEnumerator <int> iterator2 = publish.GetEnumerator(); // | | // iterator2: 3 4 | | iterator2.MoveNext(); Trace.WriteLine(iterator2.Current); // |3|Trace: 3 iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 3| | iterator2.MoveNext(); Trace.WriteLine(iterator2.Current); // |4|Trace: 4 iterator1.MoveNext(); Trace.WriteLine(iterator1.Current); // 4| | // Trace: 0 1 2 3 4. publish.Dispose(); iterator1.MoveNext(); // ObjectDisposedException. iterator2.MoveNext(); // ObjectDisposedException. }
public void Dispose() { Buffer.Dispose(); }
public void Dealloc(IBuffer buffer) { // Deallocate the buffer, since we're an unpooled allocator we don't really need to do much, // other than to dispose the buffer buffer.Dispose(this); }
public void Dispose() { buffer.Dispose(); GC.SuppressFinalize(this); }
public void Draw() { var sketches = sketchService.GetSketches(); var totalPointCount = sketches.Sum(x => x.Count); if (totalPointCount == 0) { return; } if (data == null || totalPointCount > data.Length) { vertexBuffer?.Dispose(); var size = data?.Length ?? 1024; while (size < totalPointCount) { size *= 2; } data = new Vector2[size]; vertexBuffer = glContext.Create.Buffer(BufferTarget.Array, data.Length * sizeof(Vector2), BufferUsageHint.DynamicDraw); vao.SetVertexAttributeF(0, vertexBuffer, VertexAttributeDimension.Two, VertexAttribPointerType.Float, false, sizeof(Vector2), 0); } int offset = 0; foreach (var sketch in sketches) { foreach (var point in sketch) { data[offset++] = point; } } var sketchSize = totalPointCount * sizeof(Vector2); var map = vertexBuffer.Map(0, sketchSize, MapAccess.Write | MapAccess.InvalidateRange); fixed(Vector2 *pData = data) PtrHelper.CopyBulk((byte *)map, (byte *)pData, sketchSize); vertexBuffer.Unmap(); glContext.Bindings.Program.Set(shaderProgram); glContext.Bindings.VertexArray.Set(vao); glContext.States.DepthStencil.DepthTestEnable.Set(false); glContext.States.DepthStencil.DepthMask.Set(false); OpenTK.Graphics.OpenGL4.GL.LineWidth(6f); offset = 0; foreach (var sketch in sketches) { glContext.Actions.Draw.Arrays(BeginMode.LineStrip, offset, sketch.Count); offset += sketch.Count; } OpenTK.Graphics.OpenGL4.GL.LineWidth(1f); glContext.States.DepthStencil.DepthTestEnable.Set(true); glContext.States.DepthStencil.DepthMask.Set(true); }
public void Dealloc(IBuffer buffer) { this._bufferIndexPool.Push((buffer as DefaultBuffer).Offset); buffer.Dispose(this); }
public void Dispose() { _buffer.Dispose(); }
public void Dispose() => _buffer.Dispose();