Intrinsify random nextState, improve perfromance significantly.

runtime/vm/intrinsifier_ia32.cc

 // Copyright (c) 2013, 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.
 //
 // The intrinsic code below is executed before a method has built its frame.
 // The return address is on the stack and the arguments below it.
 // Registers EDX (arguments descriptor) and ECX (function) must be preserved.
 // Each intrinsification method returns true if the corresponding
 // Dart method was intrinsified.
 
 #include "vm/globals.h"  // Needed here to get TARGET_ARCH_IA32.
 #if defined(TARGET_ARCH_IA32)
 
 #include "vm/intrinsifier.h"
 
 #include "vm/assembler.h"
+#include "vm/flow_graph_compiler.h"
 #include "vm/object.h"
 #include "vm/object_store.h"
 #include "vm/os.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DECLARE_FLAG(bool, enable_type_checks);
 
@@ skipping 1393 matching lines @@
   return false;  // Compile method for slow case.
 }
 
 
 bool Intrinsifier::Math_cos(Assembler* assembler) {
   EmitTrigonometric(assembler, kCosine);
   return false;  // Compile method for slow case.
 }
 
 
+//    var state = ((_A * (_state[kSTATE_LO])) + _state[kSTATE_HI]) & _MASK_64;
+//    _state[kSTATE_LO] = state & _MASK_32;
+//    _state[kSTATE_HI] = state >> 32;
+bool Intrinsifier::Random_nextState(Assembler* assembler) {
+  const Library& math_lib = Library::Handle(Library::MathLibrary());
+  ASSERT(!math_lib.IsNull());
+  const Class& random_class =
+      Class::Handle(math_lib.LookupClassAllowPrivate(Symbols::_Random()));
+  ASSERT(!random_class.IsNull());
+  const Field& state_field = Field::ZoneHandle(
+      random_class.LookupInstanceField(Symbols::_state()));
+  ASSERT(!state_field.IsNull());
+  const Field& random_A_field = Field::ZoneHandle(
+      random_class.LookupStaticField(Symbols::_A()));
+  ASSERT(!random_A_field.IsNull());
+  ASSERT(random_A_field.is_const());
+  const Instance& a_value = Instance::Handle(random_A_field.value());
+  const int64_t a_int_value = Integer::Cast(a_value).AsInt64Value();
+  // 'a_int_value' is a mask.
+  ASSERT(a_int_value <= 0xFFFFFFFF);

[zra, 2013/05/20 23:38:17]

I'm not sure what this ASSERT and the next line are trying to accomplish, but
the test in the ASSERT will be a signed comparison, which I'm guessing is not
what you want. Maybe use Utils::IsInt or Utils::IsUint as appropriate in the
ASSERT?

[srdjan, 2013/05/20 23:48:25]

Using Utils::IsUint(32, a_int_value);
Since immediate accepts only int32, I am converting it. It is a mask so only
bits matter.

+  int32_t a_int32_value = static_cast<int32_t>(a_int_value);
+  __ movl(EAX, Address(ESP, + 1 * kWordSize));  // Receiver.
+  __ movl(EBX, FieldAddress(EAX, state_field.Offset()));  // Field '_state'.
+  // Addresses of _state[0] and _state[1].
+  Address addr_0 = FlowGraphCompiler::ElementAddressForIntIndex(
+      kTypedDataUint32ArrayCid,
+      FlowGraphCompiler::ElementSizeFor(kTypedDataUint32ArrayCid),
+      EBX,
+      0);
+  Address addr_1 = FlowGraphCompiler::ElementAddressForIntIndex(
+      kTypedDataUint32ArrayCid,
+      FlowGraphCompiler::ElementSizeFor(kTypedDataUint32ArrayCid),
+      EBX,
+      1);
+  __ movl(EAX, Immediate(a_int32_value));
+  // 64-bit multiply EAX * value -> EDX:EAX.
+  __ mull(addr_0);
+  __ addl(EAX, addr_1);
+  __ adcl(EDX, Immediate(0));
+  __ movl(addr_1, EDX);
+  __ movl(addr_0, EAX);
+  __ ret();
+  return true;
+}
+
+
 // Identity comparison.
 bool Intrinsifier::Object_equal(Assembler* assembler) {
   Label is_true;
   __ movl(EAX, Address(ESP, + 1 * kWordSize));
   __ cmpl(EAX, Address(ESP, + 2 * kWordSize));
   __ j(EQUAL, &is_true, Assembler::kNearJump);
   __ LoadObject(EAX, Bool::False());
   __ ret();
   __ Bind(&is_true);
   __ LoadObject(EAX, Bool::True());
@@ skipping 274 matching lines @@
   __ ret();
 
   __ Bind(&fall_through);
   return false;
 }
 
 #undef __
 }  // namespace dart
 
 #endif  // defined TARGET_ARCH_IA32