public T CalculateResponsible(Guid guid) { byte[] guidBytes = guid.ToByteArray(); uint uniformHashCode = JenkinsHash.ComputeHash(guidBytes); return(CalculateResponsible(uniformHashCode)); }
public override void Write(BinaryWriter bw) { bw.Write(JenkinsHash.getHash32(this.Class)); bw.Write(JenkinsHash.getHash32(this.RowName)); bw.Write(0); bw.Write(this.Factor); }
/// <summary> /// Create a subscriptionId that is unique per grainId, grainType, namespace combination. /// </summary> private Guid MakeSubscriptionGuid(GrainType grainType, InternalChannelId channelId) { // next 2 shorts inc guid are from namespace hash var namespaceHash = JenkinsHash.ComputeHash(channelId.GetNamespace()); var namespaceHashByes = BitConverter.GetBytes(namespaceHash); var s1 = BitConverter.ToInt16(namespaceHashByes, 0); var s2 = BitConverter.ToInt16(namespaceHashByes, 2); // Tailing 8 bytes of the guid are from the hash of the channelId Guid and a hash of the provider name. // get channelId guid hash code var channelIdGuidHash = JenkinsHash.ComputeHash(channelId.ChannelId.Key.Span); // get provider name hash code var providerHash = JenkinsHash.ComputeHash(channelId.ProviderName); // build guid tailing 8 bytes from grainIdHash and the hash of the provider name. var tail = new List <byte>(); tail.AddRange(BitConverter.GetBytes(channelIdGuidHash)); tail.AddRange(BitConverter.GetBytes(providerHash)); // make guid. // - First int is grain type // - Two shorts from namespace hash // - 8 byte tail from channelId Guid and provider name hash. var id = new Guid((int)JenkinsHash.ComputeHash(grainType.ToString()), s1, s2, tail.ToArray()); var result = MarkSubscriptionGuid(id, isImplicitSubscription: true); return(result); }
private Guid GenerateDeterministicGuid(QueueId queueId) { // provider name hash code JenkinsHash jenkinsHash = JenkinsHash.Factory.GetHashGenerator(); int providerNameGuidHash = (int)jenkinsHash.ComputeHash(providerName); // get queueId hash code uint queueIdHash = queueId.GetUniformHashCode(); byte[] queIdHashByes = BitConverter.GetBytes(queueIdHash); short s1 = BitConverter.ToInt16(queIdHashByes, 0); short s2 = BitConverter.ToInt16(queIdHashByes, 2); // build guid tailing 8 bytes from providerNameGuidHash and queIdHashByes. var tail = new List <byte>(); tail.AddRange(BitConverter.GetBytes(providerNameGuidHash)); tail.AddRange(queIdHashByes); // make guid. // - First int is provider name hash // - Two shorts from queue Id hash // - 8 byte tail from provider name hash and queue Id hash. return(new Guid(providerNameGuidHash, s1, s2, tail.ToArray())); }
public VLTTypeResolver() { this._typeTable = new Dictionary <uint, Type>(); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Double"), typeof(EADouble)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Float"), typeof(EAFloat)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::UInt8"), typeof(EAUInt8)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::UInt16"), typeof(EAUInt16)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::UInt32"), typeof(EAUInt32)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::UInt64"), typeof(EAUInt64)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Int8"), typeof(EAInt8)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Int16"), typeof(EAInt16)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Int32"), typeof(EAInt32)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Int64"), typeof(EAInt64)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Bool"), typeof(EABool)); this._typeTable.Add(JenkinsHash.getHash32("EA::Reflection::Text"), typeof(EAText)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::Types::Matrix"), typeof(AttribMatrix)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::Types::Vector2"), typeof(AttribVector2)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::Types::Vector3"), typeof(AttribVector3)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::Types::Vector4"), typeof(AttribVector4)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::RefSpec"), typeof(AttribRefSpec)); this._typeTable.Add(JenkinsHash.getHash32("Attrib::Blob"), typeof(AttribBlob)); #if CARBON this._typeTable.Add(JenkinsHash.getHash32("Attrib::StringKey"), typeof(AttribStringKeyCarbon)); #else this._typeTable.Add(JenkinsHash.getHash32("Attrib::StringKey"), typeof(AttribStringKey)); #endif this._typeTable.Add(JenkinsHash.getHash32("AxlePair"), typeof(AxlePair)); this._typeTable.Add(JenkinsHash.getHash32("CarBodyMotion"), typeof(CarBodyMotion)); this._typeTable.Add(JenkinsHash.getHash32("GCollectionKey"), typeof(GCollectionKey)); this._typeTable.Add(JenkinsHash.getHash32("JunkmanMod"), typeof(JunkmanMod)); this._typeTable.Add(JenkinsHash.getHash32("UpgradeSpecs"), typeof(UpgradeSpecs)); }
private VltTypeMap() { _typeDictionary = new Dictionary <uint, Type> { { JenkinsHash.getHash32("EA::Reflection::Int8"), typeof(EaInt8) }, { JenkinsHash.getHash32("EA::Reflection::Int16"), typeof(EaInt16) }, { JenkinsHash.getHash32("EA::Reflection::Int32"), typeof(EaInt32) }, { JenkinsHash.getHash32("EA::Reflection::Int64"), typeof(EaInt64) }, { JenkinsHash.getHash32("EA::Reflection::UInt8"), typeof(EaUInt8) }, { JenkinsHash.getHash32("EA::Reflection::UInt16"), typeof(EaUInt16) }, { JenkinsHash.getHash32("EA::Reflection::UInt32"), typeof(EaUInt32) }, { JenkinsHash.getHash32("EA::Reflection::UInt64"), typeof(EaUInt64) }, { JenkinsHash.getHash32("EA::Reflection::Bool"), typeof(EaBoolean) }, { JenkinsHash.getHash32("EA::Reflection::Float"), typeof(EaFloat) }, { JenkinsHash.getHash32("EA::Reflection::Double"), typeof(EaDouble) }, { JenkinsHash.getHash32("EA::Reflection::Text"), typeof(EaText) }, { JenkinsHash.getHash32("Attrib::RefSpec"), typeof(RefSpec) }, { JenkinsHash.getHash32("Attrib::StringKey"), typeof(StringKey) }, { JenkinsHash.getHash32("Attrib::Types::Matrix"), typeof(Matrix) }, { JenkinsHash.getHash32("Attrib::Types::Vector2"), typeof(Vector2) }, { JenkinsHash.getHash32("Attrib::Types::Vector3"), typeof(Vector3) }, { JenkinsHash.getHash32("Attrib::Types::Vector4"), typeof(Vector4) }, { JenkinsHash.getHash32("Attrib::Blob"), typeof(Blob) }, { JenkinsHash.getHash32("GCollectionKey"), typeof(CollectionKey) }, { JenkinsHash.getHash32("AirSupport"), typeof(AirSupport) }, { JenkinsHash.getHash32("AxlePair"), typeof(AxlePair) }, }; }
public QueueProperties(string @namespace, uint partitionId = 0) { Namespace = @namespace; PartitionId = partitionId; QueueName = $"{@namespace}_{partitionId.ToString()}"; Hash = JenkinsHash.ComputeHash(@namespace); }
/// <summary> /// Create a subscriptionId that is unique per grainId, grainType, namespace combination. /// </summary> private Guid MakeSubscriptionGuid(GrainType grainType, InternalStreamId streamId) { // next 2 shorts inc guid are from namespace hash uint namespaceHash = JenkinsHash.ComputeHash(streamId.GetNamespace()); byte[] namespaceHashByes = BitConverter.GetBytes(namespaceHash); short s1 = BitConverter.ToInt16(namespaceHashByes, 0); short s2 = BitConverter.ToInt16(namespaceHashByes, 2); // Tailing 8 bytes of the guid are from the hash of the streamId Guid and a hash of the provider name. // get streamId guid hash code uint streamIdGuidHash = JenkinsHash.ComputeHash(streamId.StreamId.Key.Span); // get provider name hash code uint providerHash = JenkinsHash.ComputeHash(streamId.ProviderName); // build guid tailing 8 bytes from grainIdHash and the hash of the provider name. var tail = new List <byte>(); tail.AddRange(BitConverter.GetBytes(streamIdGuidHash)); tail.AddRange(BitConverter.GetBytes(providerHash)); // make guid. // - First int is grain type // - Two shorts from namespace hash // - 8 byte tail from streamId Guid and provider name hash. var id = new Guid((int)JenkinsHash.ComputeHash(grainType.ToString()), s1, s2, tail.ToArray()); var result = SubscriptionMarker.MarkAsImplictSubscriptionId(id); return(result); }
private List <uint> GetUniformHashCodesImpl(int numHashes) { Span <byte> bytes = stackalloc byte[16 + sizeof(int) + sizeof(int) + sizeof(int)]; // ip + port + generation + extraBit // Endpoint IP Address var address = Endpoint.Address; if (address.AddressFamily == AddressFamily.InterNetwork) // IPv4 { #pragma warning disable CS0618 // Type or member is obsolete BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(12), (int)address.Address); #pragma warning restore CS0618 bytes.Slice(0, 12).Clear(); } else // IPv6 { address.GetAddressBytes().CopyTo(bytes); } var offset = 16; // Port BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(offset), Endpoint.Port); offset += sizeof(int); // Generation BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(offset), Generation); offset += sizeof(int); var hashes = new List <uint>(numHashes); for (int extraBit = 0; extraBit < numHashes; extraBit++) { BinaryPrimitives.WriteInt32LittleEndian(bytes.Slice(offset), extraBit); hashes.Add(JenkinsHash.ComputeHash(bytes)); } return(hashes); }
public uint GetUniformHashCode() { if (uniformHashCache == 0) { JenkinsHash jenkinsHash = JenkinsHash.Factory.GetHashGenerator(); byte[] guidBytes = Guid.ToByteArray(); byte[] providerBytes = Encoding.UTF8.GetBytes(ProviderName); byte[] allBytes; if (Namespace == null) { allBytes = new byte[guidBytes.Length + providerBytes.Length]; Array.Copy(guidBytes, allBytes, guidBytes.Length); Array.Copy(providerBytes, 0, allBytes, guidBytes.Length, providerBytes.Length); } else { byte[] namespaceBytes = Encoding.UTF8.GetBytes(Namespace); allBytes = new byte[guidBytes.Length + providerBytes.Length + namespaceBytes.Length]; Array.Copy(guidBytes, allBytes, guidBytes.Length); Array.Copy(providerBytes, 0, allBytes, guidBytes.Length, providerBytes.Length); Array.Copy(namespaceBytes, 0, allBytes, guidBytes.Length + providerBytes.Length, namespaceBytes.Length); } uniformHashCache = jenkinsHash.ComputeHash(allBytes); } return(uniformHashCache); }
/// <summary> /// Create a subscriptionId that is unique per grainId, grainType, namespace combination. /// </summary> /// <param name="grainIdTypeCode"></param> /// <param name="streamId"></param> /// <returns></returns> private Guid MakeSubscriptionGuid(int grainIdTypeCode, StreamId streamId) { // next 2 shorts ing guid are from namespace hash uint namespaceHash = JenkinsHash.ComputeHash(streamId.Namespace); byte[] namespaceHashByes = BitConverter.GetBytes(namespaceHash); short s1 = BitConverter.ToInt16(namespaceHashByes, 0); short s2 = BitConverter.ToInt16(namespaceHashByes, 2); // Tailing 8 bytes of the guid are from the hash of the streamId Guid and a hash of the provider name. // get streamId guid hash code uint streamIdGuidHash = JenkinsHash.ComputeHash(streamId.Guid.ToByteArray()); // get provider name hash code uint providerHash = JenkinsHash.ComputeHash(streamId.ProviderName); // build guid tailing 8 bytes from grainIdHash and the hash of the provider name. var tail = new List <byte>(); tail.AddRange(BitConverter.GetBytes(streamIdGuidHash)); tail.AddRange(BitConverter.GetBytes(providerHash)); // make guid. // - First int is grain type // - Two shorts from namespace hash // - 8 byte tail from streamId Guid and provider name hash. return(SubscriptionMarker.MarkAsImplictSubscriptionId(new Guid(grainIdTypeCode, s1, s2, tail.ToArray()))); }
public T GetNode(string key) { var hash = JenkinsHash.ComputeHash(Encoding.UTF8.GetBytes(key)); int index = (int)(hash % _nodes.Length); return(_nodes[index]); }
internal uint GetUniformHashCode() { // Disabling this ReSharper warning; hashCache is a logically read-only variable, so accessing them in GetHashCode is safe. // ReSharper disable NonReadonlyFieldInGetHashCode if (uniformHashCache == 0) { JenkinsHash jenkinsHash = JenkinsHash.Factory.GetHashGenerator(); uint n; if (HasKeyExt && KeyExt != null) { var writer = new BinaryTokenStreamWriter(); writer.Write(this); byte[] bytes = writer.ToByteArray(); writer.ReleaseBuffers(); n = jenkinsHash.ComputeHash(bytes); } else { n = jenkinsHash.ComputeHash(TypeCodeData, N0, N1); } // Unchecked is required because the Jenkins hash is an unsigned 32-bit integer, // which we need to convert to a signed 32-bit integer. uniformHashCache = n; } return(uniformHashCache); // ReSharper restore NonReadonlyFieldInGetHashCode }
public T CalculateResponsible(Guid guid) { JenkinsHash jenkinsHash = JenkinsHash.Factory.GetHashGenerator(); byte[] guidBytes = guid.ToByteArray(); uint uniformHashCode = jenkinsHash.ComputeHash(guidBytes); return(CalculateResponsible(uniformHashCode)); }
private uint GetUniformHashCode(JenkinsHash jenkinsHash, int extraBit) { var writer = new BinaryTokenStreamWriter(); writer.Write(this); writer.Write(extraBit); byte[] bytes = writer.ToByteArray(); return(jenkinsHash.ComputeHash(bytes)); }
public static void AddHash(string value) { var hash = JenkinsHash.getHash32(value); if (!Hashes.ContainsKey(hash)) { Hashes[hash] = value; } }
private void Validate(string file) { var j = new JenkinsHash(); ulong hash = j.ComputeHash(file); if (TargetHashes.Contains(hash)) { ResultStrings.Enqueue(file); } }
private void CheckFieldName(string name) { int computedHash = JenkinsHash.GetHashCode(name); int hash = this.reader.ReadInt32(); if (computedHash != hash) { throw new InvalidOperationException("The field hash is not what was expected..."); } }
/// <summary> /// Performs the Jenkins hash on an input byte array /// </summary> public static byte[] JenkinsHash(byte[] input) { using (JenkinsHash jHash = new JenkinsHash()) { byte[] hash = jHash.ComputeHash(input); Array.Reverse(hash); return(hash); } }
private void Validate(IEnumerable <string> files) { Parallel.ForEach(files, x => { ulong hash = new JenkinsHash().ComputeHash(x); if (Array.IndexOf(TargetHashes, hash, HashesLookup[hash & 0xFF], BucketSize) > -1) { ResultStrings.Enqueue(x); FileNames.Add(x); // add new files as we go } }); }
public static void AddAuto(string value) { uint key = JenkinsHash.getHash32(value); if (!_autoTable.ContainsKey(key)) { _autoTable.Add(key, value); if (_loadTable.ContainsKey(key)) { _loadTable.Remove(key); } } }
public static void addHashFromVLTDB(string A_0) { uint hash = JenkinsHash.getHash32(A_0); if (!HashTracker.hashesFromVLTFile.ContainsKey(hash)) { HashTracker.hashesFromVLTFile[hash] = A_0; if (HashTracker.hashesFromTextFile.ContainsKey(hash)) { HashTracker.hashesFromTextFile.Remove(hash); } } }
private void Validate(ref ConcurrentBag <string> files) { Parallel.ForEach(files, x => { var j = new JenkinsHash(); ulong hash = j.ComputeHash(x); if (Array.IndexOf(TargetHashes, hash, HashesLookup[hash & 0xFF], BucketSize) > -1) { ResultStrings.Enqueue(x); } }); files = new ConcurrentBag <string>(); }
private void Validate(ref ConcurrentBag <string> files) { Parallel.ForEach(files, x => { var j = new JenkinsHash(); ulong hash = j.ComputeHash(x); if (TargetHashes.Contains(hash)) { ResultStrings.Enqueue(x); } }); files = new ConcurrentBag <string>(); }
private void Validate(IEnumerable <string> files) { Parallel.ForEach(files, x => { ulong hash = new JenkinsHash().ComputeHash(x); if (TargetHashes.Contains(hash)) { ResultStrings.Enqueue(x); FileNames.Add(x); // add new files as we go } x = null; }); }
public QueueProperties( string @namespace, uint partitionId = 0, bool isExternal = false, Type externalContractType = null ) { Namespace = @namespace; PartitionId = partitionId; QueueName = $"{@namespace}_{partitionId.ToString()}"; Hash = JenkinsHash.ComputeHash(@namespace); IsExternal = isExternal; ExternalContractType = externalContractType; }
/// <summary> /// Open the Jenkins hash dialog. /// </summary> private async void DoJenkinsHashCommand() { var strToHash = await _dialogCoordinator.ShowInputAsync(this, "Jenkins Hash", "What would you like to hash?"); if (string.IsNullOrWhiteSpace(strToHash)) { return; } var hash32 = JenkinsHash.GetHash32(strToHash); var hash64 = JenkinsHash.GetHash64(strToHash); await _dialogCoordinator.ShowMessageAsync(this, "Hash Result", $"The 32-bit Jenkins hash of \"{strToHash}\" is 0x{hash32:X8}.\nThe 64-bit Jenkins hash is 0x{hash64:X16}."); }
public override int GetHashCode() { JenkinsHash hash = new JenkinsHash(); hash.Mixin(VectorHelper.GetX(p0).GetHashCode()); hash.Mixin(VectorHelper.GetY(p0).GetHashCode()); hash.Mixin(VectorHelper.GetX(p1).GetHashCode()); hash.Mixin(VectorHelper.GetY(p1).GetHashCode()); hash.Mixin(VectorHelper.GetX(p2).GetHashCode()); hash.Mixin(VectorHelper.GetY(p2).GetHashCode()); hash.Mixin(VectorHelper.GetX(p3).GetHashCode()); hash.Mixin(VectorHelper.GetY(p3).GetHashCode()); return(hash.GetValue()); }
public void ID_HashCorrectness() { // This tests that our optimized Jenkins hash computes the same value as the reference implementation int testCount = 1000; for (int i = 0; i < testCount; i++) { byte[] byteData = new byte[24]; random.NextBytes(byteData); ulong u1 = BitConverter.ToUInt64(byteData, 0); ulong u2 = BitConverter.ToUInt64(byteData, 8); ulong u3 = BitConverter.ToUInt64(byteData, 16); var referenceHash = JenkinsHash.ComputeHash(byteData); var optimizedHash = JenkinsHash.ComputeHash(u1, u2, u3); Assert.Equal(referenceHash, optimizedHash); // "Optimized hash value doesn't match the reference value for inputs {0}, {1}, {2}", u1, u2, u3 } }
private void Validate(string mask, byte[] maskoffsets) { char[] maskdata = mask.ToCharArray(); // sanity check the results var j = new JenkinsHash(); while (ResultQueue.Count > 0) { string s = StringGenerator.Generate(maskdata, ResultQueue.Dequeue(), maskoffsets, IsMirrored); ulong h = j.ComputeHash(s); if (TargetHashes.Contains(h)) { ResultStrings.Add(s); } } }
/// <summary> /// Performs the Jenkins hash on an input byte array /// </summary> public static byte[] JenkinsHash( byte[] input ) { using ( JenkinsHash jHash = new JenkinsHash() ) { byte[] hash = jHash.ComputeHash( input ); Array.Reverse( hash ); return hash; } }