[vm] Better implementation of hashCode function.

With this cl hashCode function for integers which used to be identity function becomes `uint128_t hash = value * constant; hash ^= hash >> 64; hash ^= hash >> 32; hash &= 0x3fffffff`. Note that the hashCode has to stay the same across platforms(64-bit/32-bit).

This dramatically improves performance of integer HashSet/HashMap lookups when integers differ in higher bits only(see the issue referenced below).

AOT ARM64 benchmarks:
===
WordSolverIdentity -3.630% (-0.9 noise)
BigInt.parse.0064.bits 15.43% (0.9 noise)
BigInt.parse.4096.bits 40.80% (1.6 noise)
BigInt.parse.0256.bits 42.01% (2.3 noise)
BigInt.parse.1024.bits 50.91% (2.6 noise)
IntegerSetLookup.DefaultHashSet 549916% (14727.6 noise)
IntegerSetLookup.DefaultHashSet 597150% (55520.2 noise)
IntegerSetLookup.HashSet 846924% (78126.7 noise)
IntegerSetLookup.HashSet 791864% (107221.1 noise)
===

AOT x64:
===
Havlak -14.25% (-1.7 noise)
DartMicroBench.Int64Div -7.091% (-1.2 noise)
ObjectHash.manual.5 -9.541% (-0.8 noise)
AsyncLiveVars.LiveInt1 4.726% (0.8 noise)
IsolateJson.SendAndExit_Decode1MBx1 9.067% (0.8 noise)
SplayHarderLatency 4.629% (0.9 noise)
TypedDataDuplicate.Float64List.32.loop 35.01% (1.8 noise)
IntegerSetLookup.DefaultHashSet 627996% (124823.6 noise)
IntegerSetLookup.HashSet 1245362% (244705.3 noise)
===

JIT ARM64:
===
IntegerSetLookup.DefaultHashSet_Random 73.80% (1.2 noise)
IntegerSetLookup.DefaultHashSet 344999% (6202.9 noise)
IntegerSetLookup.HashSet 483731% (7845.7 noise)
===

JIT x64:
===
CollectionSieves-Set-removeLoop -6.294% (-0.9 noise)
Utf8Encode.ru.10M 59.11% (0.8 noise)
Utf8Encode.ru.10k 71.62% (0.9 noise)
Utf8Encode.zh.10M 53.93% (0.9 noise)
Utf8Encode.ne.10k 71.34% (0.9 noise)
Utf8Encode.zh.10k 72.52% (0.9 noise)
Utf8Encode.ne.10M 53.17% (0.9 noise)
IntegerSetLookup.HashSet_Random 27.80% (1.1 noise)
String.replaceAll.String.Zero 8.659% (1.2 noise)
IntegerSetLookup.DefaultHashSet_Random 96.20% (1.3 noise)
IntegerSetLookup.HashSet 481037% (18028.8 noise)
IntegerSetLookup.DefaultHashSet 454450% (31501.3 noise)
==

Fixes dart-lang/sdk#48641
TEST=ci

Change-Id: Id982e4aa30cd1d6a63f93c73917a8b921ad464a3
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/258600
Reviewed-by: Ryan Macnak <rmacnak@google.com>
Commit-Queue: Alexander Aprelev <aam@google.com>

Author: aam

runtime/lib/double.cc

@@ -2,6 +2,8 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include "lib/integers.h"
+
 #include "vm/bootstrap_natives.h"
 
 #include <math.h>  // NOLINT
@@ -76,7 +78,7 @@ DEFINE_NATIVE_ENTRY(Double_hashCode, 0, 1) {
       (val <= kMaxInt64RepresentableAsDouble)) {
     int64_t ival = static_cast<int64_t>(val);
     if (static_cast<double>(ival) == val) {
-      return Integer::New(ival);
+      return Integer::New(Multiply64Hash(ival));
     }
   }
 

runtime/lib/integers.cc

@@ -2,6 +2,7 @@
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
+#include "lib/integers.h"
 #include "vm/bootstrap_natives.h"
 
 #include "include/dart_api.h"
@@ -271,6 +272,37 @@ DEFINE_NATIVE_ENTRY(Smi_bitLength, 0, 1) {
   return Smi::New(result);
 }
 
+// Should be kept in sync with
+//  - il_(x64/arm64/...).cc HashIntegerOpInstr,
+//  - asm_intrinsifier(...).cc Multiply64Hash
+uint32_t Multiply64Hash(int64_t ivalue) {
+  const uint64_t magic_constant = /*0x1b873593cc9e*/ 0x2d51;
+  uint64_t value = static_cast<uint64_t>(ivalue);
+#if defined(ARCH_IS_64_BIT)
+#ifdef _MSC_VER
+  __int64 hi = __umulh(value, magic_constant);
+  uint64_t lo = value * magic_constant;
+  uint64_t hash = lo ^ hi;
+#else
+  const __int128 res = static_cast<__int128>(value) * magic_constant;
+  uint64_t hash = res ^ static_cast<int64_t>(res >> 64);
+#endif
+  hash = hash ^ (hash >> 32);
+#else
+  uint64_t prod_lo64 = value * magic_constant;
+
+  uint64_t value_lo32 = value & 0xffffffff;
+  uint64_t value_hi32 = value >> 32;
+  uint64_t carry = (((value_hi32 * magic_constant) & 0xffffffff) +
+                    ((value_lo32 * magic_constant) >> 32)) >>
+                   32;
+  uint64_t prod_hi64 = ((value_hi32 * magic_constant) >> 32) + carry;
+  uint64_t hash = prod_hi64 ^ prod_lo64;
+  hash = hash ^ (hash >> 32);
+#endif
+  return hash & 0x3fffffff;
+}
+
 // Mint natives.
 
 DEFINE_NATIVE_ENTRY(Mint_bitNegate, 0, 1) {

runtime/lib/integers.h

@@ -0,0 +1,16 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+#ifndef RUNTIME_LIB_INTEGERS_H_
+#define RUNTIME_LIB_INTEGERS_H_
+
+#include "platform/globals.h"
+
+namespace dart {
+
+uint32_t Multiply64Hash(int64_t value);
+
+}  // namespace dart
+
+#endif  // RUNTIME_LIB_INTEGERS_H_

runtime/tests/vm/dart/generic_field_invocation_test.dart

@@ -16,5 +16,5 @@ class C {
 main() {
   var c = C();
   c.field = <T>(T x) => x.hashCode;
-  Expect.equals(3, c.field<dynamic>(3));
+  Expect.equals(3.hashCode, c.field<dynamic>(3));
 }

runtime/tests/vm/dart/hashcode_int_values_test.dart

@@ -0,0 +1,33 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// VMOptions=--intrinsify
+// VMOptions=--no_intrinsify
+
+import 'package:expect/expect.dart';
+
+main() {
+  // We do not guarantee any particular hash function for integers,
+  // but our implementation relies on the hash function being the same
+  // across architectures.
+  <int, int>{
+    0: 0x0,
+    -0: 0x0,
+    1: 0x2d51,
+    -1: 0x0,
+    0xffff: 0x2d50d2af,
+    -0xffff: 0x2d50fffe,
+    0xffffffff: 0x3fffffff,
+    -0xffffffff: 0x3fffd2ae,
+    0x111111111111: 0x25630507,
+    -0x111111111111: 0x25632856,
+    0xffffffffffff: 0x12af2d50,
+    -0xffffffffffff: 0x12af0001,
+    9007199254840856: 0x2f2da59d,
+    144115188075954880: 0x26761e9a,
+    936748722493162112: 0x196ac8cd,
+  }.forEach((value, expected) {
+    Expect.equals(expected, value.hashCode, "${value}.hashCode");
+  });
+}

runtime/tests/vm/dart_2/generic_field_invocation_test.dart

@@ -18,5 +18,5 @@ class C {
 main() {
   var c = C();
   c.field = <T>(T x) => x.hashCode;
-  Expect.equals(3, c.field<dynamic>(3));
+  Expect.equals(3.hashCode, c.field<dynamic>(3));
 }

runtime/tests/vm/dart_2/hashcode_int_values_test.dart

@@ -0,0 +1,35 @@
+// Copyright (c) 2022, the Dart project authors.  Please see the AUTHORS file
+// for details. All rights reserved. Use of this source code is governed by a
+// BSD-style license that can be found in the LICENSE file.
+
+// VMOptions=--intrinsify
+// VMOptions=--no_intrinsify
+
+// @dart = 2.9
+
+import 'package:expect/expect.dart';
+
+main() {
+  // We do not guarantee any particular hash function for integers,
+  // but our implementation relies on the hash function being the same
+  // across architectures.
+  <int, int>{
+    0: 0x0,
+    -0: 0x0,
+    1: 0x2d51,
+    -1: 0x0,
+    0xffff: 0x2d50d2af,
+    -0xffff: 0x2d50fffe,
+    0xffffffff: 0x3fffffff,
+    -0xffffffff: 0x3fffd2ae,
+    0x111111111111: 0x25630507,
+    -0x111111111111: 0x25632856,
+    0xffffffffffff: 0x12af2d50,
+    -0xffffffffffff: 0x12af0001,
+    9007199254840856: 0x2f2da59d,
+    144115188075954880: 0x26761e9a,
+    936748722493162112: 0x196ac8cd,
+  }.forEach((value, expected) {
+    Expect.equals(expected, value.hashCode, "${value}.hashCode");
+  });
+}

runtime/vm/compiler/asm_intrinsifier_arm.cc

@@ -945,6 +945,24 @@ void AsmIntrinsifier::Double_getIsNegative(Assembler* assembler,
   __ b(&is_false);
 }
 
+// Input: tagged integer in R0
+// Output: tagged hash code value in R0
+// Should be kept in sync with
+//  - il_(x64/arm64/...).cc HashIntegerOpInstr,
+//  - asm_intrinsifier(...).cc Multiply64Hash
+//  - integers.cc Multiply64Hash
+static void Multiply64Hash(Assembler* assembler) {
+  __ SmiUntag(R0);
+  __ SignFill(R1, R0);  // sign extend R0 to R1
+  __ LoadImmediate(TMP, compiler::Immediate(0x2d51));
+  __ umull(TMP, R0, R0, TMP);  // (R0:TMP) = R0 * 0x2d51
+  //  (0:0:R0:TMP) is 128-bit product
+  __ eor(R0, TMP, compiler::Operand(R0));
+  __ eor(R0, R1, compiler::Operand(R0));
+  __ AndImmediate(R0, R0, 0x3fffffff);
+  __ SmiTag(R0);
+}
+
 void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
                                       Label* normal_ir_body) {
   // TODO(dartbug.com/31174): Convert this to a graph intrinsic.
@@ -975,7 +993,9 @@ void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
   __ vcvtdi(D1, S2);
   __ vcmpd(D0, D1);
   __ vmstat();
-  READS_RETURN_ADDRESS_FROM_LR(__ bx(LR, EQ));
+  __ b(&double_hash, NE);
+  Multiply64Hash(assembler);
+  __ Ret();
   // Convert the double bits to a hash code that fits in a Smi.
   __ Bind(&double_hash);
   __ ldr(R0, FieldAddress(R1, target::Double::value_offset()));

runtime/vm/compiler/asm_intrinsifier_arm64.cc

@@ -1100,6 +1100,23 @@ void AsmIntrinsifier::Double_getIsNegative(Assembler* assembler,
   __ ret();
 }
 
+// Input: tagged integer in R0
+// Output: tagged hash code value in R0
+// Should be kept in sync with
+//  - il_(x64/arm64/...).cc HashIntegerOpInstr,
+//  - asm_intrinsifier(...).cc Multiply64Hash
+//  - integers.cc Multiply64Hash
+static void Multiply64Hash(Assembler* assembler) {
+  __ SmiUntag(R0);
+  __ LoadImmediate(TMP, compiler::Immediate(0x2d51));
+  __ mul(R1, TMP, R0);
+  __ umulh(TMP, TMP, R0);
+  __ eor(R0, R1, compiler::Operand(TMP));
+  __ eor(R0, R0, compiler::Operand(R0, LSR, 32));
+  __ AndImmediate(R0, R0, 0x3fffffff);
+  __ SmiTag(R0);
+}
+
 void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
                                       Label* normal_ir_body) {
   // TODO(dartbug.com/31174): Convert this to a graph intrinsic.
@@ -1136,6 +1153,8 @@ void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
   // Smi tagged result immediately as the hash code.
   __ fcmpd(V0, V1);
   __ b(&double_hash, NE);
+
+  Multiply64Hash(assembler);
   __ ret();
 
   // Convert the double bits to a hash code that fits in a Smi.

runtime/vm/compiler/asm_intrinsifier_ia32.cc

@@ -1073,6 +1073,30 @@ void AsmIntrinsifier::Double_getIsNegative(Assembler* assembler,
   __ jmp(&is_false, Assembler::kNearJump);
 }
 
+// Input: tagged integer in EAX
+// Output: tagged hash code value in EAX
+//  - il_(x64/arm64/...).cc HashIntegerOpInstr,
+//  - asm_intrinsifier(...).cc Multiply64Hash
+//  - integers.cc Multiply64Hash
+static void Multiply64Hash(Assembler* assembler) {
+  __ SmiUntag(EAX);
+  __ cdq();           // // sign-extend EAX to EDX
+  __ movl(ECX, EDX);  // save "value_hi" in ECX
+  __ movl(EDX, compiler::Immediate(0x2d51));
+  __ mull(EDX);       // (EDX:EAX) = value_lo * 0x2d51
+  __ movl(EBX, EAX);  // save lo32 in EBX
+  __ movl(EAX, ECX);  // get saved value_hi
+  __ movl(ECX, EDX);  // save hi32 in ECX
+  __ movl(EDX, compiler::Immediate(0x2d51));
+  __ mull(EDX);       // (EDX:EAX) = value_hi * 0x2d51
+  __ addl(EAX, ECX);  // EAX has prod_hi32, EDX has prod_hi64_lo32
+
+  __ xorl(EAX, EDX);  // EAX = prod_hi32 ^ prod_hi64_lo32
+  __ xorl(EAX, EBX);  // result = prod_hi32 ^ prod_hi64_lo32 ^ prod_lo32
+  __ andl(EAX, compiler::Immediate(0x3fffffff));
+  __ SmiTag(EAX);
+}
+
 void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
                                       Label* normal_ir_body) {
   // TODO(dartbug.com/31174): Convert this to a graph intrinsic.
@@ -1096,6 +1120,8 @@ void AsmIntrinsifier::Double_hashCode(Assembler* assembler,
   Label double_hash;
   __ comisd(XMM0, XMM1);
   __ j(NOT_EQUAL, &double_hash, Assembler::kNearJump);
+
+  Multiply64Hash(assembler);
   __ ret();
 
   // Convert the double bits to a hash code that fits in a Smi.