public unsafe VarLenHeapContainer(ref T obj, IVariableLengthStruct <T> varLenStruct, SectorAlignedBufferPool pool) { var len = varLenStruct.GetLength(ref obj); mem = pool.Get(len); Buffer.MemoryCopy(Unsafe.AsPointer(ref obj), mem.GetValidPointer(), len, len); }
private void UpdateVarlen(ref IVariableLengthStruct <Value, Input> variableLengthStruct) { if (!(fht.hlog is VariableLengthBlittableAllocator <Key, Value>)) { return; } if (typeof(Value) == typeof(SpanByte) && typeof(Input) == typeof(SpanByte)) { variableLengthStruct = new SpanByteVarLenStructForSpanByteInput() as IVariableLengthStruct <Value, Input>; } else if (typeof(Value).IsGenericType && (typeof(Value).GetGenericTypeDefinition() == typeof(Memory <>)) && Utility.IsBlittableType(typeof(Value).GetGenericArguments()[0])) { if (typeof(Input).IsGenericType && (typeof(Input).GetGenericTypeDefinition() == typeof(Memory <>)) && typeof(Input).GetGenericArguments()[0] == typeof(Value).GetGenericArguments()[0]) { var m = typeof(MemoryVarLenStructForMemoryInput <>).MakeGenericType(typeof(Value).GetGenericArguments()); object o = Activator.CreateInstance(m); variableLengthStruct = o as IVariableLengthStruct <Value, Input>; } else if (typeof(Input).IsGenericType && (typeof(Input).GetGenericTypeDefinition() == typeof(ReadOnlyMemory <>)) && typeof(Input).GetGenericArguments()[0] == typeof(Value).GetGenericArguments()[0]) { var m = typeof(MemoryVarLenStructForReadOnlyMemoryInput <>).MakeGenericType(typeof(Value).GetGenericArguments()); object o = Activator.CreateInstance(m); variableLengthStruct = o as IVariableLengthStruct <Value, Input>; } } }
public VariableLengthBlittableAllocator(LogSettings settings, VariableLengthStructSettings <Key, Value> vlSettings, IFasterEqualityComparer <Key> comparer, Action <long, long> evictCallback = null, LightEpoch epoch = null, Action <CommitInfo> flushCallback = null) : base(settings, comparer, evictCallback, epoch, flushCallback) { values = new byte[BufferSize][]; handles = new GCHandle[BufferSize]; pointers = new long[BufferSize]; ptrHandle = GCHandle.Alloc(pointers, GCHandleType.Pinned); nativePointers = (long *)ptrHandle.AddrOfPinnedObject(); KeyLength = vlSettings.keyLength; ValueLength = vlSettings.valueLength; if (KeyLength == null) { fixedSizeKey = true; KeyLength = new FixedLengthStruct <Key>(); } if (ValueLength == null) { fixedSizeValue = true; ValueLength = new FixedLengthStruct <Value>(); } }
public unsafe VarLenHeapContainer(ref T obj, IVariableLengthStruct <T> varLenStruct, SectorAlignedBufferPool pool) { this.varLenStruct = varLenStruct; var len = varLenStruct.GetLength(ref obj); mem = pool.Get(len); varLenStruct.Serialize(ref obj, mem.GetValidPointer()); }
public void Copy(ref MyValue src, ref MyValue dst, IVariableLengthStruct <MyValue> valueLength) { if (src.value == 21) { CopyCalled = true; } dst = src; }
public void Copy(ref ValueStruct src, ref ValueStruct dst, IVariableLengthStruct <ValueStruct> valueLength) { if (src.vfield1 == 11 && src.vfield2 == 21) { CopyCalled = true; } dst = src; }
public void Copy(ref Value src, ref Value dst, IVariableLengthStruct <Value> valueLength) { var srcLength = valueLength.GetLength(ref src); Buffer.MemoryCopy( Unsafe.AsPointer(ref src), Unsafe.AsPointer(ref dst), srcLength, srcLength); }
public bool CopyInPlace(ref Memory <T> src, ref Memory <T> dst, IVariableLengthStruct <Memory <T> > valueLength) { if (src.Length > dst.Length) { return(false); } src.CopyTo(dst); dst.ShrinkSerializedLength(src.Length); return(true); }
/// <inheritdoc /> public FasterKV(long size, Functions functions, LogSettings logSettings, CheckpointSettings checkpointSettings = null, SerializerSettings <Key, Value> serializerSettings = null, IFasterEqualityComparer <Key> comparer = null, VariableLengthStructSettings <Key, Value> variableLengthStructSettings = null, IVariableLengthStruct <Value, Input> variableLengthStructForInput = null) { _functions = functions; _fasterKV = new FasterKV <Key, Value>(size, logSettings, checkpointSettings, serializerSettings, comparer, variableLengthStructSettings); _variableLengthStructForInput = variableLengthStructForInput; if (_fasterKV.hlog is VariableLengthBlittableAllocator <Key, Value> allocator && _variableLengthStructForInput == default) { _variableLengthStructForInput = new DefaultVariableLengthStruct <Value, Input>(allocator.ValueLength); } }
public bool CopyInPlace(ref Value src, ref Value dst, IVariableLengthStruct <Value> valueLength) { var srcLength = valueLength.GetLength(ref src); var dstLength = valueLength.GetLength(ref dst); if (srcLength != dstLength) { return(false); } Buffer.MemoryCopy( Unsafe.AsPointer(ref src), Unsafe.AsPointer(ref dst), dstLength, srcLength); return(true); }
public VariableLengthBlittableAllocator(LogSettings settings, VariableLengthStructSettings <Key, Value> vlSettings, IFasterEqualityComparer <Key> comparer, Action <long, long> evictCallback = null, LightEpoch epoch = null, Action <CommitInfo> flushCallback = null) : base(settings, comparer, evictCallback, epoch, flushCallback) { overflowPagePool = new OverflowPool <PageUnit>(4, p => #if NET5_0_OR_GREATER { } #else p.handle.Free() #endif ); if (BufferSize > 0) { values = new byte[BufferSize][]; #if NET5_0_OR_GREATER pointers = GC.AllocateArray <long>(BufferSize, true); nativePointers = (long *)Unsafe.AsPointer(ref pointers[0]); #else pointers = new long[BufferSize]; handles = new GCHandle[BufferSize]; ptrHandle = GCHandle.Alloc(pointers, GCHandleType.Pinned); nativePointers = (long *)ptrHandle.AddrOfPinnedObject(); #endif } KeyLength = vlSettings.keyLength; ValueLength = vlSettings.valueLength; if (KeyLength == null) { fixedSizeKey = true; KeyLength = new FixedLengthStruct <Key>(); } if (ValueLength == null) { fixedSizeValue = true; ValueLength = new FixedLengthStruct <Value>(); } }
internal ClientSession( FasterKV <Key, Value> fht, FasterKV <Key, Value> .FasterExecutionContext <Input, Output, Context> ctx, Functions functions, bool supportAsync, SessionVariableLengthStructSettings <Value, Input> sessionVariableLengthStructSettings = null) { this.fht = fht; this.ctx = ctx; this.functions = functions; SupportAsync = supportAsync; LatestCommitPoint = new CommitPoint { UntilSerialNo = -1, ExcludedSerialNos = null }; FasterSession = new AsyncFasterSession(this); this.variableLengthStruct = sessionVariableLengthStructSettings?.valueLength; if (this.variableLengthStruct == default) { if (fht.hlog is VariableLengthBlittableAllocator <Key, Value> allocator) { Debug.WriteLine("Warning: Session did not specify Input-specific functions for variable-length values via IVariableLengthStruct<Value, Input>"); this.variableLengthStruct = new DefaultVariableLengthStruct <Value, Input>(allocator.ValueLength); } } else { if (!(fht.hlog is VariableLengthBlittableAllocator <Key, Value>)) { Debug.WriteLine("Warning: Session param of variableLengthStruct provided for non-varlen allocator"); } } this.inputVariableLengthStruct = sessionVariableLengthStructSettings?.inputLength; // Session runs on a single thread if (!supportAsync) { UnsafeResumeThread(); } }
/// <summary> /// Default instance of object /// </summary> /// <param name="variableLengthStruct"></param> public DefaultVariableLengthStruct(IVariableLengthStruct <T> variableLengthStruct) { this.variableLengthStruct = variableLengthStruct; }
internal ClientSession( FasterKV <Key, Value> fht, FasterKV <Key, Value> .FasterExecutionContext <Input, Output, Context> ctx, Functions functions, bool supportAsync, SessionVariableLengthStructSettings <Value, Input> sessionVariableLengthStructSettings = null) { this.fht = fht; this.ctx = ctx; this.functions = functions; SupportAsync = supportAsync; LatestCommitPoint = new CommitPoint { UntilSerialNo = -1, ExcludedSerialNos = null }; FasterSession = new AsyncFasterSession(this); this.variableLengthStruct = sessionVariableLengthStructSettings?.valueLength; if (this.variableLengthStruct == default) { UpdateVarlen(ref this.variableLengthStruct); if ((this.variableLengthStruct == default) && (fht.hlog is VariableLengthBlittableAllocator <Key, Value> allocator)) { Debug.WriteLine("Warning: Session did not specify Input-specific functions for variable-length values via IVariableLengthStruct<Value, Input>"); this.variableLengthStruct = new DefaultVariableLengthStruct <Value, Input>(allocator.ValueLength); } } else { if (!(fht.hlog is VariableLengthBlittableAllocator <Key, Value>)) { Debug.WriteLine("Warning: Session param of variableLengthStruct provided for non-varlen allocator"); } } this.inputVariableLengthStruct = sessionVariableLengthStructSettings?.inputLength; if (inputVariableLengthStruct == default) { if (typeof(Input) == typeof(SpanByte)) { inputVariableLengthStruct = new SpanByteVarLenStruct() as IVariableLengthStruct <Input>; } else if (typeof(Input).IsGenericType && (typeof(Input).GetGenericTypeDefinition() == typeof(Memory <>)) && Utility.IsBlittableType(typeof(Input).GetGenericArguments()[0])) { var m = typeof(MemoryVarLenStruct <>).MakeGenericType(typeof(Input).GetGenericArguments()); object o = Activator.CreateInstance(m); inputVariableLengthStruct = o as IVariableLengthStruct <Input>; } else if (typeof(Input).IsGenericType && (typeof(Input).GetGenericTypeDefinition() == typeof(ReadOnlyMemory <>)) && Utility.IsBlittableType(typeof(Input).GetGenericArguments()[0])) { var m = typeof(ReadOnlyMemoryVarLenStruct <>).MakeGenericType(typeof(Input).GetGenericArguments()); object o = Activator.CreateInstance(m); inputVariableLengthStruct = o as IVariableLengthStruct <Input>; } } // Session runs on a single thread if (!supportAsync) { UnsafeResumeThread(); } }
/// <summary> /// Resume (continue) prior client session with FASTER, used during /// recovery from failure. /// For performance reasons this overload is not recommended if functions is value type (struct). /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of previous session to resume</param> /// <param name="commitPoint">Prior commit point of durability for session</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> > ResumeSession <Input, Output, Context>(IFunctions <Key, Value, Input, Output, Context> functions, string sessionId, out CommitPoint commitPoint, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) { return(ResumeSession <Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> >(functions, sessionId, out commitPoint, threadAffinitized, variableLengthStruct)); }
public bool CopyInPlace(ref MyValue src, ref MyValue dst, IVariableLengthStruct <MyValue> valueLength) { dst = src; return(true); }
public void Copy(ref MyValue src, ref MyValue dst, IVariableLengthStruct <MyValue> valueLength) { dst = src; }
public bool CopyInPlace(ref MyValue src, ref MyValue dst, IVariableLengthStruct <MyValue> valueLength) { return(false); }
/// <summary> /// Resume (continue) prior client session with FASTER, used during /// recovery from failure. /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of previous session to resume</param> /// <param name="commitPoint">Prior commit point of durability for session</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, Functions> ResumeSession <Input, Output, Context, Functions>(Functions functions, string sessionId, out CommitPoint commitPoint, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) where Functions : IFunctions <Key, Value, Input, Output, Context> { if (functions == null) { throw new ArgumentNullException(nameof(functions)); } if (!threadAffinitized) { UseRelaxedCPR(); } commitPoint = InternalContinue <Input, Output, Context>(sessionId, out var ctx); if (commitPoint.UntilSerialNo == -1) { throw new Exception($"Unable to find session {sessionId} to recover"); } var session = new ClientSession <Key, Value, Input, Output, Context, Functions>(this, ctx, functions, !threadAffinitized, variableLengthStruct); if (_activeSessions == null) { Interlocked.CompareExchange(ref _activeSessions, new Dictionary <string, IClientSession>(), null); } lock (_activeSessions) _activeSessions.Add(sessionId, session); return(session); }
public KeyValueStore(string folder, int logSizeBits, IFasterEqualityComparer <TKey> keyComparer, TFunctions functions, IVariableLengthStruct <TKey> keyLength, IVariableLengthStruct <TValue> valueLength) { _dataFolder = folder; _logSizeBits = logSizeBits; _keyComparer = keyComparer; _functions = functions; _variableLenSettings = new VariableLengthStructSettings <TKey, TValue> { keyLength = keyLength, valueLength = valueLength }; }
/// <summary> /// Start a new client session with FASTER. /// For performance reasons this overload is not recommended if functions is value type (struct). /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of session (auto-generated if not provided)</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> > NewSession <Input, Output, Context>(IFunctions <Key, Value, Input, Output, Context> functions, string sessionId = null, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) { return(NewSession <Input, Output, Context, IFunctions <Key, Value, Input, Output, Context> >(functions, sessionId, threadAffinitized, variableLengthStruct)); }
public void Copy(ref Memory <T> src, ref Memory <T> dst, IVariableLengthStruct <Memory <T> > valueLength) { src.CopyTo(dst); }
/// <summary> /// Resume (continue) prior client session with FASTER, used during /// recovery from failure. /// </summary> /// <param name="sessionId">ID/name of previous session to resume</param> /// <param name="commitPoint">Prior commit point of durability for session</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, Functions> ResumeSession <Functions>(string sessionId, out CommitPoint commitPoint, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) where Functions : IFunctions <Key, Value, Input, Output, Context> { if (_functions == null) { throw new FasterException("Functions not provided for session"); } return(_fasterKV.ResumeSession <Input, Output, Context, Functions>((Functions)_functions, sessionId, out commitPoint, threadAffinitized, variableLengthStruct)); }
public void Copy(ref ValueStruct src, ref ValueStruct dst, IVariableLengthStruct <ValueStruct> valueLength) { dst = src; }
/// <summary> /// Start a new client session with FASTER. /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of session (auto-generated if not provided)</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, Functions> NewSession <Input, Output, Context, Functions>(Functions functions, string sessionId = null, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) where Functions : IFunctions <Key, Value, Input, Output, Context> { if (functions == null) { throw new ArgumentNullException(nameof(functions)); } if (!threadAffinitized) { UseRelaxedCPR(); } if (sessionId == null) { sessionId = Guid.NewGuid().ToString(); } var ctx = new FasterExecutionContext <Input, Output, Context>(); InitContext(ctx, sessionId); var prevCtx = new FasterExecutionContext <Input, Output, Context>(); InitContext(prevCtx, sessionId); prevCtx.version--; ctx.prevCtx = prevCtx; if (_activeSessions == null) { Interlocked.CompareExchange(ref _activeSessions, new Dictionary <string, IClientSession>(), null); } var session = new ClientSession <Key, Value, Input, Output, Context, Functions>(this, ctx, functions, !threadAffinitized, variableLengthStruct); lock (_activeSessions) _activeSessions.Add(sessionId, session); return(session); }
public bool CopyInPlace(ref ValueStruct src, ref ValueStruct dst, IVariableLengthStruct <ValueStruct> valueLength) { return(false); }
/// <summary> /// Resume (continue) prior client session with FASTER, used during /// recovery from failure. /// </summary> /// <param name="functions">Callback functions</param> /// <param name="sessionId">ID/name of previous session to resume</param> /// <param name="commitPoint">Prior commit point of durability for session</param> /// <param name="threadAffinitized">For advanced users. Specifies whether session holds the thread epoch across calls. Do not use with async code. Ensure thread calls session Refresh periodically to move the system epoch forward.</param> /// <param name="variableLengthStruct">Implementation of input-specific length computation for variable-length structs</param> /// <returns>Session instance</returns> public ClientSession <Key, Value, Input, Output, Context, Functions> ResumeSession <Functions>(Functions functions, string sessionId, out CommitPoint commitPoint, bool threadAffinitized = false, IVariableLengthStruct <Value, Input> variableLengthStruct = null) where Functions : IFunctions <Key, Value, Input, Output, Context> { return(_fasterKV.ResumeSession <Input, Output, Context, Functions>(functions, sessionId, out commitPoint, threadAffinitized, variableLengthStruct)); }
public bool CopyInPlace(ref ValueStruct src, ref ValueStruct dst, IVariableLengthStruct <ValueStruct> valueLength) { dst = src; return(true); }