public void ApplyBitXorTo(UnmanagedSliceBuilder value) { uint size = checked ((uint)this.Value.Count); // truncate the value if larger, or pad it with zeroes if shorter value.Resize(size, 0); if (size > 0) { unsafe { fixed(byte *ptr = this.Value.Array) { byte *left = value.Data; byte *right = ptr + this.Value.Offset; //TODO: find a way to optimize this for common sizes like 4 or 8 bytes! while (size-- > 0) { *left++ ^= *right++; } } } } }
/// <summary>Checks if a list of reads conflicts with at least one write performed in this transaction window</summary> /// <param name="reads">List of reads to check for conflicts</param> /// <param name="version">Sequence number of the transaction that performed the reads</param> /// <returns>True if at least one read is conflicting with a write with a higher sequence number; otherwise, false.</returns> public bool Conflicts(ColaRangeSet <Slice> reads, ulong version) { Contract.Requires(reads != null); //Debug.WriteLine("* Testing for conflicts for: " + String.Join(", ", reads)); if (version > m_maxVersion) { // all the writes are before the reads, so no possible conflict! //Debug.WriteLine(" > cannot conflict"); return(false); } using (var scratch = new UnmanagedSliceBuilder()) { //TODO: do a single-pass version of intersection checking ! foreach (var read in reads) { scratch.Clear(); scratch.Append(read.Begin); var p = scratch.Count; scratch.Append(read.End); var begin = scratch.ToUSlice(p); var end = scratch.ToUSlice(p, scratch.Count - p); if (m_writeConflicts.Intersect(begin, end, version, (v, min) => v > min)) { Debug.WriteLine(" > Conflicting read: " + read); return(true); } } } //Debug.WriteLine(" > No conflicts found"); return(false); }
public void ApplyAddTo(UnmanagedSliceBuilder value) { uint size = checked ((uint)this.Value.Count); // if the value is empty, then this is the same thing as adding to 0 if (value.Count == 0) { value.Append(this.Value); return; } // truncate the value if larger, or pad it with zeroes if shorter value.Resize(size, 0); if (size > 0) { unsafe { fixed(byte *ptr = this.Value.Array) { byte *left = value.Data; byte *right = ptr + this.Value.Offset; //TODO: find a way to optimize this for common sizes like 4 or 8 bytes! int carry = 0; while (size-- > 0) { carry += *left + *right++; *left++ = (byte)carry; carry >>= 8; } } } } }