public static unsafe int CallArrayDoubleArrayDouble(DataStructure *data) { if (data->printf_fct != null) { return(CaptureStdOutput(CallArrayDoubleArrayDouble, data)); } CallArrayDoubleArrayDoubleIO *input = (CallArrayDoubleArrayDoubleIO *)data->inputs; var vec = new double[input->nb]; double *src = (double *)input->p; for (int i = 0; i < vec.Length; ++i) { vec[i] = src[i]; } Int64 *p_fct = (Int64 *)data->exc; var fctref = ObjectStorage.Inst.Get(*p_fct); var fct = fctref.MethodInfo; var cs_output = fct.Invoke(null, new object[] { vec }) as double[]; CallArrayDoubleArrayDoubleIO *output = (CallArrayDoubleArrayDoubleIO *)data->outputs; output->nb = cs_output.Length; if (cs_output.Length > 0) { NativeAllocation allocate = MarshalDelegate <NativeAllocation>(data->allocate_fct); int size = cs_output.Length * sizeof(double); allocate(size, out output->p); Marshal.Copy(cs_output, 0, (IntPtr)output->p, cs_output.Length); } return(0); }
/// <summary> /// Creates a new VCDIFF Encoder. The input streams will not be closed once this object is disposed. /// </summary> /// <param name="source">The dictionary (sourceStream file).</param> /// <param name="target">The target to create the diff from.</param> /// <param name="outputStream">The stream to write the diff into.</param> /// <param name="maxBufferSize">The maximum buffer size for window chunking in megabytes (MiB).</param> /// <param name="blockSize"> /// The block size to use. Must be a power of two. No match smaller than this block size will be identified. /// Increasing blockSize by a factor of two will halve the amount of memory needed for the next block table, and will halve the setup time /// for a new BlockHash. However, it also doubles the minimum match length that is guaranteed to be found. /// /// Blocksizes that are n mod 32 = 0 are AVX2 accelerated. Blocksizes that are n mod 16 = 0 are SSE2 accelerated, if supported. 16 is a good default /// for most scenarios, but you should use a block size of 32 or 64 for very similar data, or to optimize for speed. /// </param> /// <param name="chunkSize"> /// The minimum size of a string match that is worth putting into a COPY. This must be bigger than twice the block size.</param> /// <param name="rollingHash"> /// Manually provide a <see cref="RollingHash"/> instance that can be reused for multiple encoding instances /// of the same block size. /// /// If you provide a <see cref="RollingHash"/> instance, you must dispose of it yourself. /// </param> /// <exception cref="ArgumentException">If an invalid blockSize or chunkSize is used..</exception> public unsafe VcEncoder(Stream source, Stream target, Stream outputStream, int maxBufferSize = 1, int blockSize = 16, int chunkSize = 0, RollingHash?rollingHash = null) { _nativeAllocation = new NativeAllocation <byte>((int)source.Length); source.Read(_nativeAllocation.AsSpan()); this.oldData = new ByteBuffer(_nativeAllocation.AsSpan()); InitializeEncoder(target, outputStream, maxBufferSize, blockSize, chunkSize, rollingHash); }
public void Return(byte *ptr, long size, NativeMemory.ThreadStats allocatingThread, long generation) { if (ptr == null) { return; } Interlocked.Add(ref _currentlyInUseBytes, -size); Sodium.sodium_memzero(ptr, (UIntPtr)size); var numberOfPages = size / Constants.Storage.PageSize; if (Disabled || numberOfPages > MaxNumberOfPagesToCache || (_isLowMemory.IsRaised() && generation < Generation)) { // - don't want to pool large buffers // - release all the buffers that were created before we got the low memory event ForTestingPurposes?.OnFree4KbAlignedMemory?.Invoke(size); PlatformSpecific.NativeMemory.Free4KbAlignedMemory(ptr, size, allocatingThread); return; } var index = Bits.MostSignificantBit(size); var allocation = new NativeAllocation { Ptr = ptr, Size = size, InPoolSince = DateTime.UtcNow }; var addToPerCorePool = ForTestingPurposes == null || ForTestingPurposes.CanAddToPerCorePool; var success = addToPerCorePool ? _items[index].TryPush(allocation) : false; if (success) { // updating the thread allocations since we released the memory back to the pool ForTestingPurposes?.OnUpdateMemoryStatsForThread?.Invoke(size); NativeMemory.UpdateMemoryStatsForThread(allocatingThread, size); return; } var addToGlobalPool = ForTestingPurposes == null || ForTestingPurposes.CanAddToGlobalPool; var currentGlobalStack = _globalStacks[index]; if (addToGlobalPool && currentGlobalStack.Count < _maxNumberOfAllocationsToKeepInGlobalStackPerSlot) { // updating the thread allocations since we released the memory back to the pool ForTestingPurposes?.OnUpdateMemoryStatsForThread?.Invoke(size); NativeMemory.UpdateMemoryStatsForThread(allocatingThread, size); currentGlobalStack.Push(allocation); return; } ForTestingPurposes?.OnFree4KbAlignedMemory?.Invoke(size); PlatformSpecific.NativeMemory.Free4KbAlignedMemory(ptr, size, allocatingThread); }
public static unsafe int RandomString(DataStructure *data) { string text = "Français"; var raw = StringToNullTerminatedBytesUTF8(text); NativeAllocation allocate = MarshalDelegate <NativeAllocation>(data->allocate_fct); allocate(raw.Length, out data->outputs); data->exc = null; Marshal.Copy(raw, 0, (IntPtr)data->outputs, raw.Length); return(0); }
public static unsafe int CsUpper(DataStructure *data) { string text = BytesToString((sbyte *)data->inputs); text = text.ToUpper(); var raw = StringToNullTerminatedBytesUTF8(text); NativeAllocation allocate = MarshalDelegate <NativeAllocation>(data->allocate_fct); allocate(raw.Length, out data->outputs); data->exc = null; Marshal.Copy(raw, 0, (IntPtr)data->outputs, raw.Length); return(0); }
public static unsafe int CallArrayInt32String(DataStructure *data) { if (data->printf_fct != null) { return(CaptureStdOutput(CallArrayInt32String, data)); } string content = BytesToString((sbyte *)data->inputs); Int64 *p_fct = (Int64 *)data->exc; var fctref = ObjectStorage.Inst.Get(*p_fct); var fct = fctref.MethodInfo; var cs_output = fct.Invoke(null, new object[] { content }) as int[]; CallArrayInt32StringOutput *output = (CallArrayInt32StringOutput *)data->outputs; output->nb = cs_output.Length; if (cs_output.Length > 0) { NativeAllocation allocate = MarshalDelegate <NativeAllocation>(data->allocate_fct); int size = cs_output.Length * sizeof(int); allocate(size, out output->p); Marshal.Copy(cs_output, 0, (IntPtr)output->p, cs_output.Length); } return(0); }
public static unsafe int CreateFunction(DataStructure *data) { CreateFunctionInput *inputPtr = (CreateFunctionInput *)data->inputs; Int64 *outputPtr = (Int64 *)data->outputs; string name = BytesToString((sbyte *)inputPtr->namePointer); string code = BytesToString((sbyte *)inputPtr->codePointer); string clrPath = BytesToString((sbyte *)inputPtr->clrPath); sbyte **c_usings = (sbyte **)inputPtr->usingsPointer; var usings = new List <string>(); while (*c_usings != null) { usings.Add(BytesToString(*c_usings)); c_usings++; } sbyte **c_dependencies = (sbyte **)inputPtr->dependenciesPointer; var dependencies = new List <string>(); while (*c_dependencies != null) { dependencies.Add(BytesToString(*c_dependencies)); c_dependencies++; } string text = ""; MethodInfo meth; try { meth = DynamicFunction.CreateFunction(name, code, usings.ToArray(), dependencies.ToArray(), clrPath); } catch (Exception exc) { meth = null; text = exc.ToString(); text = string.Format("Unable to compile function '{0}' due to {1}\n---CODE---\n{2}\n---USINGS---\n{3}\n---DEPENDENCIES---\n{4}\n---", name, exc.ToString(), code, string.Join("\n", usings), string.Join("\n", dependencies)); } if (meth != null) { try { text = DynamicFunction.MethodSignature(meth); } catch (Exception exc) { meth = null; text = string.Format("Unable to get the signature due to: {0}.", exc.ToString()); } } else if (string.IsNullOrEmpty(text)) { text = string.Format("Method '{0}' is null\n---CODE---\n{1}\n---USINGS---\n{2}\n---DEPENDENCIES---\n{3}\n---", name, code, string.Join("\n", usings), string.Join("\n", dependencies)); } *outputPtr = meth == null ? -1 : ObjectStorage.Inst.AddIncref(meth); if (meth == null) { text = text.Replace("\r", "").Replace("\n\n", "\n"); } var raw = StringToNullTerminatedBytesUTF8(text); NativeAllocation allocate = MarshalDelegate <NativeAllocation>(data->allocate_fct); allocate(raw.Length, out data->exc); Marshal.Copy(raw, 0, (IntPtr)data->exc, raw.Length); return(0); }