static bool TryWritePrimitives(Span<byte> output, Sha256 hash, string keyType, string verb, string resourceId, string resourceType, string tokenVersion, DateTime utc, out int bytesWritten) { int totalWritten = 0; bytesWritten = 0; Span<byte> buffer = stackalloc byte[AuthenticationHeaderBufferSize]; s_type.CopyTo(buffer); totalWritten += s_type.Length; if (Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(keyType.AsSpan()), buffer.Slice(totalWritten), out int consumed, out int written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } totalWritten += written; s_ver.CopyTo(buffer.Slice(totalWritten)); totalWritten += s_ver.Length; if (Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(tokenVersion.AsSpan()), buffer.Slice(totalWritten), out consumed, out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } totalWritten += written; s_sig.CopyTo(buffer.Slice(totalWritten)); totalWritten += s_sig.Length; var front = buffer.Slice(0, totalWritten); var payload = buffer.Slice(totalWritten); totalWritten = 0; if (verb.Equals("GET", StringComparison.Ordinal) || verb.Equals("get", StringComparison.Ordinal)) { s_get.CopyTo(payload); totalWritten += s_get.Length; } else if (verb.Equals("POST", StringComparison.Ordinal) || verb.Equals("post", StringComparison.Ordinal)) { s_post.CopyTo(payload); totalWritten += s_post.Length; } else if (verb.Equals("DELETE", StringComparison.Ordinal) || verb.Equals("delete", StringComparison.Ordinal)) { s_delete.CopyTo(payload); totalWritten += s_delete.Length; } else { if (Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(verb.AsSpan()), payload, out consumed, out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } if (Encodings.Ascii.ToLowerInPlace(payload.Slice(0, written), out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } payload[written] = (byte)'\n'; totalWritten += written + 1; } var bufferSlice = payload.Slice(totalWritten); if (Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(resourceType.AsSpan()), bufferSlice, out consumed, out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } if (Encodings.Ascii.ToLowerInPlace(bufferSlice.Slice(0, written), out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } bufferSlice[written] = (byte)'\n'; totalWritten += written + 1; bufferSlice = payload.Slice(totalWritten); if (Encodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(resourceId.AsSpan()), bufferSlice, out consumed, out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } bufferSlice[written] = (byte)'\n'; totalWritten += written + 1; bufferSlice = payload.Slice(totalWritten); if (!Utf8Formatter.TryFormat(utc, bufferSlice, out written, 'l')) { throw new NotImplementedException("need to resize buffer"); } bufferSlice[written] = (byte)'\n'; totalWritten += written + 1; bufferSlice = payload.Slice(totalWritten); bufferSlice[0] = (byte)'\n'; totalWritten += 1; hash.Append(buffer.Slice(front.Length, totalWritten)); if (!hash.TryWrite(buffer.Slice(front.Length), out written)) { throw new NotImplementedException("need to resize buffer"); } if (Base64.EncodeToUtf8InPlace(buffer.Slice(front.Length), written, out written) != OperationStatus.Done) { throw new NotImplementedException("need to resize buffer"); } var len = front.Length + written; if (UrlEncoder.Utf8.Encode(buffer.Slice(0, len), output, out consumed, out bytesWritten) != OperationStatus.Done) { bytesWritten = 0; return false; } return true; }
static ref T head <M, N, T>(BlockMatrix <M, N, T> src) where N : ITypeNat, new() where M : ITypeNat, new() where T : struct => ref MemoryMarshal.GetReference <T>(src.Unsized);
static ref T head <N, T>(Span <N, T> src) where T : struct where N : ITypeNat, new() => ref MemoryMarshal.GetReference <T>(src.Unsized);
public override Span<TTo> GetSpan() => MemoryMarshal.Cast<TFrom, TTo>(_from.Span);
public static ref T head <T>(BlockVector <T> src) where T : struct => ref MemoryMarshal.GetReference <T>(src.Unblocked);
private static unsafe int ReadSyncUsingAsyncHandle(SafeFileHandle handle, Span <byte> buffer, long fileOffset) { handle.EnsureThreadPoolBindingInitialized(); CallbackResetEvent resetEvent = new CallbackResetEvent(handle.ThreadPoolBinding !); NativeOverlapped * overlapped = null; try { overlapped = GetNativeOverlappedForAsyncHandle(handle, fileOffset, resetEvent); fixed(byte *pinned = &MemoryMarshal.GetReference(buffer)) { Interop.Kernel32.ReadFile(handle, pinned, buffer.Length, IntPtr.Zero, overlapped); int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle); if (errorCode == Interop.Errors.ERROR_IO_PENDING) { resetEvent.WaitOne(); errorCode = Interop.Errors.ERROR_SUCCESS; } if (errorCode == Interop.Errors.ERROR_SUCCESS) { int result = 0; if (Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref result, bWait: false)) { Debug.Assert(result >= 0 && result <= buffer.Length, $"GetOverlappedResult returned {result} for {buffer.Length} bytes request"); return(result); } errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle); } switch (errorCode) { case Interop.Errors.ERROR_HANDLE_EOF: // logically success with 0 bytes read (read at end of file) case Interop.Errors.ERROR_BROKEN_PIPE: case Interop.Errors.ERROR_INVALID_PARAMETER when IsEndOfFileForNoBuffering(handle, fileOffset): // EOF on a pipe. Callback will not be called. // We clear the overlapped status bit for this special case (failure // to do so looks like we are freeing a pending overlapped later). overlapped->InternalLow = IntPtr.Zero; return(0); default: throw Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path); } } } finally { if (overlapped != null) { resetEvent.FreeNativeOverlapped(overlapped); } resetEvent.Dispose(); } }
private static void WriteSectionHeader(ScenarioSectionHeader header, BinaryWriter output) { output.Write(MemoryMarshal.Cast <ScenarioSectionHeader, byte>( MemoryMarshal.CreateSpan(ref header, 1) )); }
private static ByteArrayContent ToByteArrayContent(ReadOnlyMemory <byte> content) => MemoryMarshal.TryGetArray(content, out var segment) ? new ByteArrayContent(segment.Array, segment.Offset, segment.Count) // TODO: Just throw? : new ByteArrayContent(content.ToArray());
static bool TryWritePrimitive(Span <byte> output, Sha256 hash, string verb, string canonicalizedResource, DateTime utc, out int bytesWritten) { int written, consumed; bytesWritten = 0; if (verb.Equals("GET", StringComparison.Ordinal)) { if (output.Length < 3) { bytesWritten = 0; return(false); } s_GET.CopyTo(output); bytesWritten += s_GET.Length; } else { if (TextEncodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(verb.AsSpan()), output, out consumed, out written) != OperationStatus.Done) { bytesWritten = 0; return(false); } output[written] = (byte)'\n'; bytesWritten += written + 1; } var free = output.Slice(bytesWritten); s_emptyHeaders.CopyTo(free); bytesWritten += s_emptyHeaders.Length; free = output.Slice(bytesWritten); if (!Utf8Formatter.TryFormat(utc, free, out written, 'R')) { bytesWritten = 0; return(false); } free[written] = (byte)'\n'; bytesWritten += written + 1; free = output.Slice(bytesWritten); if (TextEncodings.Utf16.ToUtf8(MemoryMarshal.AsBytes(canonicalizedResource.AsSpan()), free, out consumed, out written) != OperationStatus.Done) { bytesWritten = 0; return(false); } bytesWritten += written; var formatted = output.Slice(0, bytesWritten); hash.Append(formatted); if (!hash.TryWrite(output, out written)) { throw new NotImplementedException("need to resize buffer"); } if (Base64.EncodeToUtf8InPlace(output, written, out written) != OperationStatus.Done) { bytesWritten = 0; return(false); } bytesWritten = written; return(true); }
private void WritePrimitiveList <T>(List <T> values) where T : unmanaged { Write(MemoryMarshal.AsBytes(CollectionsMarshal.AsSpan(values))); }
public Span <RGBQUAD> AsSpan() => MemoryMarshal.CreateSpan(ref e0, 256);
private void WritePrimitiveArray <T>(T[] values) where T : unmanaged { Write(MemoryMarshal.AsBytes(new ReadOnlySpan <T>(values))); }
private void StartLoop(int messageSize, int delayMicros, int burst) { _cts = new CancellationTokenSource(); var histogram = new LongHistogram(TimeSpan.FromSeconds(10).Ticks, 2); void FeedClientOnMessageReceived(ReadOnlySpan <byte> bytes) { var now = Stopwatch.GetTimestamp(); var count = Interlocked.Increment(ref _messageCounter); if (count <= _warmupSkipCount) { return; } var start = Unsafe.ReadUnaligned <long>(ref MemoryMarshal.GetReference(bytes)); var rrt = now - start; var micros = (long)(rrt * 1_000_000.0 / Stopwatch.Frequency); if (!_cts.IsCancellationRequested) { histogram.RecordValue(micros); } } _feedClientManual.MessageReceived += FeedClientOnMessageReceived; histogram.Reset(); _messageCounter = 0; var buffer = new byte[messageSize]; for (var i = 0; i < buffer.Length; i++) { buffer[i] = 42; } var rateReporter = Task.Run(async() => { var previousCount = 0L; while (!_cts.IsCancellationRequested) { var count = Volatile.Read(ref _messageCounter); var countPerSec = count - previousCount; previousCount = count; Console.WriteLine($"Processed messages: {countPerSec:N0}, total: {count:N0} [GC 0:{GC.CollectionCount(0)} 1:{GC.CollectionCount(1)}]"); await Task.Delay(1000); } }); while (!_cts.IsCancellationRequested) { _sw.Restart(); for (int i = 0; i < burst; i++) { Unsafe.WriteUnaligned(ref buffer[0], Stopwatch.GetTimestamp()); _feedClientManual.Send(buffer); } NOP(delayMicros / 1000_000.0); } _feedClientManual.MessageReceived -= FeedClientOnMessageReceived; rateReporter.Wait(); histogram.OutputPercentileDistribution(Console.Out, 1); using var writer = new StreamWriter(Path.Combine(_outFolder, $"Latency_{messageSize}_{delayMicros}.hgrm")); histogram.OutputPercentileDistribution(writer); }
public Span <D3D11_RENDER_TARGET_BLEND_DESC1> AsSpan() => MemoryMarshal.CreateSpan(ref e0, 8);
protected override bool TryGetArray(out ArraySegment <byte> segment) { _pool.CheckDisposed(); return(MemoryMarshal.TryGetArray(_owner.Memory, out segment)); }
private static unsafe string JoinInternal(ReadOnlySpan <char> first, ReadOnlySpan <char> second, ReadOnlySpan <char> third, ReadOnlySpan <char> fourth) { Debug.Assert(first.Length > 0 && second.Length > 0 && third.Length > 0 && fourth.Length > 0, "should have dealt with empty paths"); bool firstHasSeparator = PathInternal.IsDirectorySeparator(first[first.Length - 1]) || PathInternal.IsDirectorySeparator(second[0]); bool thirdHasSeparator = PathInternal.IsDirectorySeparator(second[second.Length - 1]) || PathInternal.IsDirectorySeparator(third[0]); bool fourthHasSeparator = PathInternal.IsDirectorySeparator(third[third.Length - 1]) || PathInternal.IsDirectorySeparator(fourth[0]); fixed(char *f = &MemoryMarshal.GetReference(first), s = &MemoryMarshal.GetReference(second), t = &MemoryMarshal.GetReference(third), u = &MemoryMarshal.GetReference(fourth)) { #if MS_IO_REDIST return(StringExtensions.Create( #else return string.Create( #endif first.Length + second.Length + third.Length + fourth.Length + (firstHasSeparator ? 0 : 1) + (thirdHasSeparator ? 0 : 1) + (fourthHasSeparator ? 0 : 1), (First: (IntPtr)f, FirstLength: first.Length, Second: (IntPtr)s, SecondLength: second.Length, Third: (IntPtr)t, ThirdLength: third.Length, Fourth: (IntPtr)u, FourthLength: fourth.Length, FirstHasSeparator: firstHasSeparator, ThirdHasSeparator: thirdHasSeparator, FourthHasSeparator: fourthHasSeparator), (destination, state) => { new Span <char>((char *)state.First, state.FirstLength).CopyTo(destination); if (!state.FirstHasSeparator) { destination[state.FirstLength] = PathInternal.DirectorySeparatorChar; } new Span <char>((char *)state.Second, state.SecondLength).CopyTo(destination.Slice(state.FirstLength + (state.FirstHasSeparator ? 0 : 1))); if (!state.ThirdHasSeparator) { destination[state.FirstLength + state.SecondLength + (state.FirstHasSeparator ? 0 : 1)] = PathInternal.DirectorySeparatorChar; } new Span <char>((char *)state.Third, state.ThirdLength).CopyTo(destination.Slice(state.FirstLength + state.SecondLength + (state.FirstHasSeparator ? 0 : 1) + (state.ThirdHasSeparator ? 0 : 1))); if (!state.FourthHasSeparator) { destination[destination.Length - state.FourthLength - 1] = PathInternal.DirectorySeparatorChar; } new Span <char>((char *)state.Fourth, state.FourthLength).CopyTo(destination.Slice(destination.Length - state.FourthLength)); })); } }
private static unsafe void WriteSyncUsingAsyncHandle(SafeFileHandle handle, ReadOnlySpan <byte> buffer, long fileOffset) { if (buffer.IsEmpty) { return; } handle.EnsureThreadPoolBindingInitialized(); CallbackResetEvent resetEvent = new CallbackResetEvent(handle.ThreadPoolBinding !); NativeOverlapped * overlapped = null; try { overlapped = GetNativeOverlappedForAsyncHandle(handle, fileOffset, resetEvent); fixed(byte *pinned = &MemoryMarshal.GetReference(buffer)) { Interop.Kernel32.WriteFile(handle, pinned, buffer.Length, IntPtr.Zero, overlapped); int errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle); if (errorCode == Interop.Errors.ERROR_IO_PENDING) { resetEvent.WaitOne(); errorCode = Interop.Errors.ERROR_SUCCESS; } if (errorCode == Interop.Errors.ERROR_SUCCESS) { int result = 0; if (Interop.Kernel32.GetOverlappedResult(handle, overlapped, ref result, bWait: false)) { Debug.Assert(result == buffer.Length, $"GetOverlappedResult returned {result} for {buffer.Length} bytes request"); return; } errorCode = FileStreamHelpers.GetLastWin32ErrorAndDisposeHandleIfInvalid(handle); } switch (errorCode) { case Interop.Errors.ERROR_NO_DATA: // For pipes, ERROR_NO_DATA is not an error, but the pipe is closing. return; case Interop.Errors.ERROR_INVALID_PARAMETER: // ERROR_INVALID_PARAMETER may be returned for writes // where the position is too large or for synchronous writes // to a handle opened asynchronously. throw new IOException(SR.IO_FileTooLong); default: throw Win32Marshal.GetExceptionForWin32Error(errorCode, handle.Path); } } } finally { if (overlapped != null) { resetEvent.FreeNativeOverlapped(overlapped); } resetEvent.Dispose(); } }
public static Span <bool> DecodeBools(Span <byte> span) { return(MemoryMarshal.Cast <byte, bool>(span)); }
public static unsafe IDictionary GetEnvironmentVariables() { // Format for GetEnvironmentStrings is: // [=HiddenVar=value\0]* [Variable=value\0]* \0 // See the description of Environment Blocks in MSDN's CreateProcess // page (null-terminated array of null-terminated strings). Note // the =HiddenVar's aren't always at the beginning. // Copy strings out, parsing into pairs and inserting into the table. // The first few environment variable entries start with an '='. // The current working directory of every drive (except for those drives // you haven't cd'ed into in your DOS window) are stored in the // environment block (as =C:=pwd) and the program's exit code is // as well (=ExitCode=00000000). char *stringPtr = Interop.Kernel32.GetEnvironmentStringsW(); if (stringPtr == null) { throw new OutOfMemoryException(); } try { var results = new Hashtable(); char *currentPtr = stringPtr; while (true) { ReadOnlySpan <char> variable = MemoryMarshal.CreateReadOnlySpanFromNullTerminated(currentPtr); if (variable.IsEmpty) { break; } // Find the = separating the key and value. We skip entries that begin with =. We also skip entries that don't // have =, which can happen on some older OSes when the environment block gets corrupted. int i = variable.IndexOf('='); if (i > 0) { // Add the key and value. string key = new string(variable.Slice(0, i)); string value = new string(variable.Slice(i + 1)); try { // Add may throw if the environment block was corrupted leading to duplicate entries. // We allow such throws and eat them (rather than proactively checking for duplication) // to provide a non-fatal notification about the corruption. results.Add(key, value); } catch (ArgumentException) { } } // Move to the end of this variable, after its terminator. currentPtr += variable.Length + 1; } return(results); } finally { Interop.BOOL success = Interop.Kernel32.FreeEnvironmentStringsW(stringPtr); Debug.Assert(success != Interop.BOOL.FALSE); } }
public Span <WCM_PROFILE_INFO> AsSpan(int length) => MemoryMarshal.CreateSpan(ref e0, length);
//TODO: some buffer data are reused between primitives, and I duplicate the datas //buffers must be constructed without duplications public Mesh[] LoadMeshes<TVertex> (VkIndexType indexType, Buffer vbo, ulong vboOffset, Buffer ibo, ulong iboOffset) { ulong vCount, iCount; VkIndexType idxType; GetVertexCount (out vCount, out iCount, out idxType); int vertexByteSize = Marshal.SizeOf<TVertex> (); ulong vertSize = vCount * (ulong)vertexByteSize; ulong idxSize = iCount * (indexType == VkIndexType.Uint16 ? 2ul : 4ul); ulong size = vertSize + idxSize; int vertexCount = 0, indexCount = 0; int autoNamedMesh = 1; meshes = new List<Mesh> (); using (HostBuffer stagging = new HostBuffer (dev, VkBufferUsageFlags.TransferSrc, size)) { stagging.Map (); unsafe { Span<byte> stagVertPtrInit = new Span<byte>(stagging.MappedData.ToPointer (), (int)vertSize); Span<byte> stagIdxPtrInit = new Span<byte>((byte*)stagging.MappedData.ToPointer() + vertSize, (int)idxSize); Span<byte> stagVertPtr = stagVertPtrInit, stagIdxPtr = stagIdxPtrInit; foreach (GL.Mesh mesh in gltf.Meshes) { string meshName = mesh.Name; if (string.IsNullOrEmpty (meshName)) { meshName = "mesh_" + autoNamedMesh.ToString (); autoNamedMesh++; } Mesh m = new Mesh { Name = meshName }; foreach (GL.MeshPrimitive p in mesh.Primitives) { GL.Accessor AccPos = null, AccNorm = null, AccUv = null, AccUv1 = null; int accessorIdx; if (p.Attributes.TryGetValue ("POSITION", out accessorIdx)) { AccPos = gltf.Accessors[accessorIdx]; ensureBufferIsLoaded (gltf.BufferViews[(int)AccPos.BufferView].Buffer); } if (p.Attributes.TryGetValue ("NORMAL", out accessorIdx)) { AccNorm = gltf.Accessors[accessorIdx]; ensureBufferIsLoaded (gltf.BufferViews[(int)AccNorm.BufferView].Buffer); } if (p.Attributes.TryGetValue ("TEXCOORD_0", out accessorIdx)) { AccUv = gltf.Accessors[accessorIdx]; ensureBufferIsLoaded (gltf.BufferViews[(int)AccUv.BufferView].Buffer); } if (p.Attributes.TryGetValue ("TEXCOORD_1", out accessorIdx)) { AccUv1 = gltf.Accessors[accessorIdx]; ensureBufferIsLoaded (gltf.BufferViews[(int)AccUv1.BufferView].Buffer); } Primitive prim = new Primitive { indexBase = (uint)indexCount, vertexBase = vertexCount, vertexCount = (uint)AccPos.Count, material = (uint)(p.Material ?? 0) }; prim.bb.min.ImportFloatArray (AccPos.Min); prim.bb.max.ImportFloatArray (AccPos.Max); prim.bb.isValid = true; //Interleaving vertices Span<byte> inPosPtr = Span<byte>.Empty, inNormPtr = Span<byte>.Empty, inUvPtr = Span<byte>.Empty, inUv1Ptr = Span<byte>.Empty; GL.BufferView bv = gltf.BufferViews[(int)AccPos.BufferView]; inPosPtr = loadedBuffers[bv.Buffer].Span.Slice (AccPos.ByteOffset + bv.ByteOffset); if (AccNorm != null) { bv = gltf.BufferViews[(int)AccNorm.BufferView]; inNormPtr = loadedBuffers[bv.Buffer].Span.Slice (AccNorm.ByteOffset + bv.ByteOffset); } if (AccUv != null) { bv = gltf.BufferViews[(int)AccUv.BufferView]; inUvPtr = loadedBuffers[bv.Buffer].Span.Slice (AccUv.ByteOffset + bv.ByteOffset); } if (AccUv1 != null) { bv = gltf.BufferViews[(int)AccUv1.BufferView]; inUv1Ptr = loadedBuffers[bv.Buffer].Span.Slice (AccUv1.ByteOffset + bv.ByteOffset); } //TODO: use vertex attributes scan for copying data if they exists for (int j = 0; j < prim.vertexCount; j++) { inPosPtr.Slice (0, 12).CopyTo (stagVertPtr); inPosPtr = inPosPtr.Slice(12); if (!inNormPtr.IsEmpty) { inNormPtr.Slice (0, 12).CopyTo (stagVertPtr.Slice (12)); inNormPtr = inNormPtr.Slice (12); } if (inUvPtr != null) { inUvPtr.Slice (0, 8).CopyTo (stagVertPtr.Slice (24)); inUvPtr = inUvPtr.Slice (8); } if (inUv1Ptr != null) { inUv1Ptr.Slice (0, 8).CopyTo (stagVertPtr.Slice (32)); inUv1Ptr = inUvPtr.Slice (8); } stagVertPtr = stagVertPtr.Slice (vertexByteSize); } /*Span<byte> s = stagVertPtrInit; for (int i = 0; i < s.Length; i++) Console.Write (s[i].ToString ("X2") + (i % 32 == 0 ? "\n" : " "));*/ //indices loading if (p.Indices != null) { GL.Accessor acc = gltf.Accessors[(int)p.Indices]; bv = gltf.BufferViews[(int)acc.BufferView]; Span<byte> inIdxPtr = loadedBuffers[bv.Buffer].Span.Slice (acc.ByteOffset + bv.ByteOffset); //TODO:double check this, I dont seems to increment stag pointer if (acc.ComponentType == GL.Accessor.ComponentTypeEnum.UNSIGNED_SHORT) { if (indexType == VkIndexType.Uint16) { inIdxPtr.Slice (0, acc.Count * 2).CopyTo (stagIdxPtr); stagIdxPtr = stagIdxPtr.Slice (acc.Count * 2); } else { Span<uint> usPtr = MemoryMarshal.Cast<byte, uint> (stagIdxPtr); Span<ushort> inPtr = MemoryMarshal.Cast < byte, ushort> (inIdxPtr); for (int i = 0; i < acc.Count; i++) usPtr[i] = inPtr[i]; stagIdxPtr = stagIdxPtr.Slice (acc.Count * 4); } } else if (acc.ComponentType == GL.Accessor.ComponentTypeEnum.UNSIGNED_INT) { if (indexType == VkIndexType.Uint32) { inIdxPtr.Slice (0, acc.Count * 4).CopyTo (stagIdxPtr); stagIdxPtr = stagIdxPtr.Slice (acc.Count * 4); } else { Span<ushort> usPtr = MemoryMarshal.Cast<byte, ushort> (stagIdxPtr); Span<uint> inPtr = MemoryMarshal.Cast<byte, uint> (inIdxPtr); for (int i = 0; i < acc.Count; i++) usPtr[i] = (ushort)inPtr[i]; stagIdxPtr = stagIdxPtr.Slice (acc.Count * 2); } } else if (acc.ComponentType == GL.Accessor.ComponentTypeEnum.UNSIGNED_BYTE) { //convert if (indexType == VkIndexType.Uint16) { Span<ushort> usPtr = MemoryMarshal.Cast<byte, ushort> (stagIdxPtr); for (int i = 0; i < acc.Count; i++) usPtr[i] = (ushort)inIdxPtr[i]; stagIdxPtr = stagIdxPtr.Slice (acc.Count * 2); } else { Span<uint> usPtr = MemoryMarshal.Cast<byte, uint> (stagIdxPtr); for (int i = 0; i < acc.Count; i++) usPtr[i] = (uint)inIdxPtr[i]; stagIdxPtr = stagIdxPtr.Slice (acc.Count * 4); } } else throw new NotImplementedException (); prim.indexCount = (uint)acc.Count; indexCount += acc.Count; } m.AddPrimitive (prim); vertexCount += AccPos.Count; } meshes.Add (m); } /*ReadOnlySpan<byte> tmp = new ReadOnlySpan<byte> (stagging.MappedData.ToPointer (), (int)size); Memory<byte> mtmp = new Memory<byte> (tmp.ToArray()); mtmp.Dump();*/ } stagging.Unmap (); PrimaryCommandBuffer cmd = cmdPool.AllocateCommandBuffer (); cmd.Start (VkCommandBufferUsageFlags.OneTimeSubmit); stagging.CopyTo (cmd, vbo, vertSize, 0, vboOffset); if (iCount>0) stagging.CopyTo (cmd, ibo, idxSize, vertSize, iboOffset); cmd.End (); transferQ.Submit (cmd); dev.WaitIdle (); cmd.Free (); } return meshes.ToArray (); }
public T ParseColumnData <T>() where T : struct { return(MemoryMarshal.Read <T>(RowData.Span)); }
internal static unsafe ErrorCode NCryptVerifySignature(SafeNCryptKeyHandle hKey, void *pPaddingInfo, ReadOnlySpan <byte> pbHashValue, int cbHashValue, ReadOnlySpan <byte> pbSignature, int cbSignature, AsymmetricPaddingMode dwFlags) => NCryptVerifySignature(hKey, pPaddingInfo, ref MemoryMarshal.GetReference(pbHashValue), cbHashValue, ref MemoryMarshal.GetReference(pbSignature), cbSignature, dwFlags);
/// <inheritdoc/> public override void TransferFullDuplex(ReadOnlySpan <byte> writeBuffer, Span <byte> readBuffer) { ushort readBytes; var ftStatus = FtFunction.FT4222_SPIMaster_SingleReadWrite(_ftHandle, in MemoryMarshal.GetReference(readBuffer), in MemoryMarshal.GetReference(writeBuffer), (ushort)writeBuffer.Length, out readBytes, true); if (ftStatus != FtStatus.Ok) { throw new IOException($"{nameof(TransferFullDuplex)} failed to do a full duplex transfer, error: {ftStatus}"); } }
static ref T head <N, T>(BlockVector <N, T> src) where N : ITypeNat, new() where T : struct => ref MemoryMarshal.GetReference <T>(src.Unsized);
/// <summary> /// Updates host shaders based on the guest GPU state. /// </summary> /// <param name="state">Current GPU state</param> private void UpdateShaderState(GpuState state) { ShaderAddresses addresses = new ShaderAddresses(); Span <ShaderAddresses> addressesSpan = MemoryMarshal.CreateSpan(ref addresses, 1); Span <ulong> addressesArray = MemoryMarshal.Cast <ShaderAddresses, ulong>(addressesSpan); ulong baseAddress = state.Get <GpuVa>(MethodOffset.ShaderBaseAddress).Pack(); for (int index = 0; index < 6; index++) { var shader = state.Get <ShaderState>(MethodOffset.ShaderState, index); if (!shader.UnpackEnable() && index != 1) { continue; } addressesArray[index] = baseAddress + shader.Offset; } ShaderBundle gs = ShaderCache.GetGraphicsShader(state, addresses); byte oldVsClipDistancesWritten = _vsClipDistancesWritten; _vsUsesInstanceId = gs.Shaders[0]?.Info.UsesInstanceId ?? false; _vsClipDistancesWritten = gs.Shaders[0]?.Info.ClipDistancesWritten ?? 0; if (oldVsClipDistancesWritten != _vsClipDistancesWritten) { UpdateUserClipState(state); } int storageBufferBindingsCount = 0; int uniformBufferBindingsCount = 0; for (int stage = 0; stage < Constants.ShaderStages; stage++) { ShaderProgramInfo info = gs.Shaders[stage]?.Info; _currentProgramInfo[stage] = info; if (info == null) { TextureManager.SetGraphicsTextures(stage, Array.Empty <TextureBindingInfo>()); TextureManager.SetGraphicsImages(stage, Array.Empty <TextureBindingInfo>()); BufferManager.SetGraphicsStorageBufferBindings(stage, null); BufferManager.SetGraphicsUniformBufferBindings(stage, null); continue; } var textureBindings = new TextureBindingInfo[info.Textures.Count]; for (int index = 0; index < info.Textures.Count; index++) { var descriptor = info.Textures[index]; Target target = ShaderTexture.GetTarget(descriptor.Type); textureBindings[index] = new TextureBindingInfo( target, descriptor.Binding, descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Flags); } TextureManager.SetGraphicsTextures(stage, textureBindings); var imageBindings = new TextureBindingInfo[info.Images.Count]; for (int index = 0; index < info.Images.Count; index++) { var descriptor = info.Images[index]; Target target = ShaderTexture.GetTarget(descriptor.Type); Format format = ShaderTexture.GetFormat(descriptor.Format); imageBindings[index] = new TextureBindingInfo( target, format, descriptor.Binding, descriptor.CbufSlot, descriptor.HandleIndex, descriptor.Flags); } TextureManager.SetGraphicsImages(stage, imageBindings); BufferManager.SetGraphicsStorageBufferBindings(stage, info.SBuffers); BufferManager.SetGraphicsUniformBufferBindings(stage, info.CBuffers); if (info.SBuffers.Count != 0) { storageBufferBindingsCount = Math.Max(storageBufferBindingsCount, info.SBuffers.Max(x => x.Binding) + 1); } if (info.CBuffers.Count != 0) { uniformBufferBindingsCount = Math.Max(uniformBufferBindingsCount, info.CBuffers.Max(x => x.Binding) + 1); } } BufferManager.SetGraphicsStorageBufferBindingsCount(storageBufferBindingsCount); BufferManager.SetGraphicsUniformBufferBindingsCount(uniformBufferBindingsCount); _context.Renderer.Pipeline.SetProgram(gs.HostProgram); }
static ref T head <T>(Span <T> src) => ref MemoryMarshal.GetReference <T>(src);
private static void Write(ref Span <byte> span, ushort value) { MemoryMarshal.Write(span, ref value); span = span.Slice(2); }
internal static T ParseBySpanCast <T>(ReadOnlySpan <byte> buffer) where T : struct { return(MemoryMarshal.Cast <byte, T>(buffer)[0]); }
/// <summary> /// Compute CRC32C for data /// </summary> /// <param name="input">input data</param> /// <param name="offset">offset</param> /// <param name="length">length</param> /// <returns>CRC32C checksum</returns> public static uint Compute(byte[] input, int offset, int length) { uint crcLocal = uint.MaxValue; #if NETCOREAPP3_0_OR_GREATER || NETCOREAPP3_1 || NET5_0 if (Sse42.IsSupported) { var data = new ReadOnlySpan <byte>(input, offset, length); int processed = 0; if (Sse42.X64.IsSupported && data.Length > sizeof(ulong)) { processed = data.Length / sizeof(ulong) * sizeof(ulong); var ulongs = MemoryMarshal.Cast <byte, ulong>(data.Slice(0, processed)); ulong crclong = crcLocal; for (int i = 0; i < ulongs.Length; i++) { crclong = Sse42.X64.Crc32(crclong, ulongs[i]); } crcLocal = (uint)crclong; } else if (data.Length > sizeof(uint)) { processed = data.Length / sizeof(uint) * sizeof(uint); var uints = MemoryMarshal.Cast <byte, uint>(data.Slice(0, processed)); for (int i = 0; i < uints.Length; i++) { crcLocal = Sse42.Crc32(crcLocal, uints[i]); } } for (int i = processed; i < data.Length; i++) { crcLocal = Sse42.Crc32(crcLocal, data[i]); } return(crcLocal ^ uint.MaxValue); } #endif #if NET5_0_OR_GREATER || NET5_0 if (Crc32.IsSupported) { var data = new ReadOnlySpan <byte>(input, offset, length); int processed = 0; if (Crc32.Arm64.IsSupported && data.Length > sizeof(ulong)) { processed = data.Length / sizeof(ulong) * sizeof(ulong); var ulongs = MemoryMarshal.Cast <byte, ulong>(data.Slice(0, processed)); for (int i = 0; i < ulongs.Length; i++) { crcLocal = Crc32.Arm64.ComputeCrc32C(crcLocal, ulongs[i]); } } else if (data.Length > sizeof(uint)) { processed = data.Length / sizeof(uint) * sizeof(uint); var uints = MemoryMarshal.Cast <byte, uint>(data.Slice(0, processed)); for (int i = 0; i < uints.Length; i++) { crcLocal = Crc32.ComputeCrc32C(crcLocal, uints[i]); } } for (int i = processed; i < data.Length; i++) { crcLocal = Crc32.ComputeCrc32C(crcLocal, data[i]); } return(crcLocal ^ uint.MaxValue); } #endif while (length >= 16) { var a = Table[(3 * 256) + input[offset + 12]] ^ Table[(2 * 256) + input[offset + 13]] ^ Table[(1 * 256) + input[offset + 14]] ^ Table[(0 * 256) + input[offset + 15]]; var b = Table[(7 * 256) + input[offset + 8]] ^ Table[(6 * 256) + input[offset + 9]] ^ Table[(5 * 256) + input[offset + 10]] ^ Table[(4 * 256) + input[offset + 11]]; var c = Table[(11 * 256) + input[offset + 4]] ^ Table[(10 * 256) + input[offset + 5]] ^ Table[(9 * 256) + input[offset + 6]] ^ Table[(8 * 256) + input[offset + 7]]; var d = Table[(15 * 256) + ((byte)crcLocal ^ input[offset])] ^ Table[(14 * 256) + ((byte)(crcLocal >> 8) ^ input[offset + 1])] ^ Table[(13 * 256) + ((byte)(crcLocal >> 16) ^ input[offset + 2])] ^ Table[(12 * 256) + ((crcLocal >> 24) ^ input[offset + 3])]; crcLocal = d ^ c ^ b ^ a; offset += 16; length -= 16; } while (--length >= 0) { crcLocal = Table[(byte)(crcLocal ^ input[offset++])] ^ crcLocal >> 8; } return(crcLocal ^ uint.MaxValue); }