/// <summary> /// Copies a specified number of bytes from a source buffer to a destination buffer. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="dst">The destination buffer.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(byte[] src, void *dst, int count) { fixed(byte *numRef = src) { CMemory.Copy(numRef, dst, count); } }
/// <summary> /// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="srcOffset">The byte offset into ptr2.</param> /// <param name="dst">The destination buffer.</param> /// <param name="dstOffset">The byte offset into ptr1.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(byte[] src, int srcOffset, void *dst, int dstOffset, int count) { fixed(byte *numRef = src) { CMemory.Copy(numRef + srcOffset, (byte *)dst + dstOffset, count); } }
/// <summary> /// Copies a specified number of bytes from an array of 64-bit double starting at a particular offset to a destination buffer. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="srcOffset">The byte offset into source array of double values.</param> /// <param name="dst">The destination buffer.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(double[] src, int srcOffset, void *dst, int count) { fixed(double *src_p = src) { CMemory.Copy(src_p + srcOffset, dst, count); } }
/// <summary> /// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="srcOffset">The byte offset into ptr2.</param> /// <param name="dst">The destination buffer.</param> /// <param name="dstOffset">The byte offset into ptr1.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(void *src, int srcOffset, byte[] dst, int dstOffset, int count) { fixed(byte *numRef = dst) { CMemory.Copy((byte *)src + srcOffset, numRef + dstOffset, count); } }
/// <summary> /// Copies a specified number of bytes from a source buffer to an array of 64-bit double starting at a particular offset. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="dst">The destination buffer.</param> /// <param name="dstOffset">The byte offset into the destination array of double values.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(void *src, double[] dst, int dstOffset, int count) { fixed(double *dst_p = dst) { CMemory.Copy(src, dst_p + dstOffset, count); } }
/// <summary> /// Copies a specified number of bytes from an array of 64-bit integer starting at a particular offset to a destination buffer starting at a particular offset. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="srcOffset">The byte offset into ptr2.</param> /// <param name="dst">The destination buffer.</param> /// <param name="dstOffset">The byte offset into ptr1.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(long[] src, int srcOffset, byte[] dst, int dstOffset, int count) { fixed(long *src_p = src) { fixed(byte *numRef = dst) { CMemory.Copy((byte *)src_p + srcOffset, numRef + dstOffset, count); } } }
/// <summary> /// Copies a specified number of bytes from an array of 64-bit double starting at a particular offset to a destination buffer starting at a particular offset. /// </summary> /// <param name="src">The source array of double values.</param> /// <param name="srcOffset">The offset into the source array.</param> /// <param name="dst">The destination array of double values.</param> /// <param name="dstOffset">THe offset into the destination array.</param> /// <param name="count">Note: The number of double values.</param> public static void Copy(double[] src, int srcOffset, double[] dst, int dstOffset, int count) { fixed(double *src_p = src) { fixed(double *dst_p = dst) { CMemory.Copy(src_p + srcOffset, dst_p + dstOffset, count << 3); } } }
internal static void SetMaxWorkingSet(ulong size) { CMemory.SetMaxWorkingSet(size); }
public static unsafe void *malloc(ulong size) { return(CMemory.C_malloc(size)); }
public static unsafe void free(void *buff) { CMemory.C_free(buff); }
/// <summary> /// Copies a specified number of bytes from a source buffer starting at a particular offset to a destination buffer starting at a particular offset. /// </summary> /// <param name="src">The source buffer.</param> /// <param name="srcOffset">The byte offset into ptr2.</param> /// <param name="dst">The destination buffer.</param> /// <param name="dstOffset">The byte offset into ptr1.</param> /// <param name="count">The number of bytes to copy.</param> public static unsafe void Copy(void *src, int srcOffset, void *dst, int dstOffset, int count) { CMemory.Copy((byte *)src + srcOffset, (byte *)dst + dstOffset, count); }
public static unsafe void *_aligned_malloc(long size, long alignment) { return(CMemory.C_aligned_malloc(size, alignment)); }
public static unsafe void *memset(void *buff, int value, ulong count) { return(CMemory.C_memset(buff, value, count)); }
public static unsafe int memcmp(void *ptr1, void *ptr2, ulong count) { return(CMemory.C_memcmp(ptr1, ptr2, count)); }
public static unsafe void *realloc(void *buff, ulong size) { return(CMemory.C_realloc(buff, size)); }
public static void _aligned_free(void *mem) { CMemory.C_aligned_free(mem); }
internal static void SetMemoryAllocationProfile(MemoryAllocationProfile profile) { CMemory.SetMemoryAllocationProfile(profile); }
private static void SetWorkingSetProfile(int profile) { CMemory.SetWorkingSetProfile(profile); }
public static void *AlignedAlloc(long size, long alignment) { return(CMemory.AlignedAlloc(size, alignment)); }
public static unsafe void Copy(void *src, void *dst, int count) { CMemory.Copy(src, dst, count); }
public static unsafe void *memcpy(void *dst, void *src, ulong count) { return(CMemory.C_memcpy(dst, src, count)); }
/// <summary> /// Compare bytes in two buffers. /// </summary> /// <param name="buff1">First buffer.</param> /// <param name="buff2">Second buffer.</param> /// <param name="count">Number of bytes to compare.</param> /// <returns>true if buff1 identical to buff2, otherwise false.</returns> public static unsafe bool Compare(byte *buff1, byte *buff2, int count) { return(CMemory.C_memcmp(buff2, buff1, (ulong)count) == 0); }
public static unsafe void *memmove(void *dst, void *src, ulong count) { return(CMemory.memmove(dst, src, count)); }