dart-sdk/runtime/vm/hash.h

42 lines
1 KiB
C
Raw Normal View History

// Copyright (c) 2018, 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_VM_HASH_H_
#define RUNTIME_VM_HASH_H_
#include "platform/globals.h"
namespace dart {
inline uint32_t CombineHashes(uint32_t hash, uint32_t other_hash) {
hash += other_hash;
hash += hash << 10;
hash ^= hash >> 6; // Logical shift, unsigned hash.
return hash;
}
Reland "[vm] Fix V8 snapshot profile handling of the dispatch table." This is a reland of 5909fd111d52e459b4c1885c5805849336df0f71 Does a large refactoring on the V8 snapshot profile writer to clean things up, add more debugging support, and to fix the problems that surfaced during the original landing. Other changes: Changes Serializer::CreateArtificialNodeIfNeeded() to create artificial nodes for Code objects and immutable arrays. Fixes CodeSerializationCluster::Trace() to only push needed parts of discarded code objects, instead of tracing them like full code objects. Adds test cases to v8_snapshot_profile_writer_test that exercise the following situations (both separately and together): * Non-symbolic stack traces are enabled and code and function objects are dropped when not needed at runtime. * Creation of the dispatch table is disabled. TEST=vm/dart{,_2}/v8_snapshot_profile_writer_test Original change's description: > [vm] Fix V8 snapshot profile handling of the dispatch table. > > Fixes https://github.com/dart-lang/sdk/issues/45702. > > TEST=Tests listed in the issue above. > > Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-debug-x64-try > Change-Id: Ibf5e3ccf3828c01f9dda47de360314dabe8cb8a9 > Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/195272 > Reviewed-by: Daco Harkes <dacoharkes@google.com> > Commit-Queue: Tess Strickland <sstrickl@google.com> Change-Id: I8e7030267fe190079a8f68d00fe20bf7170e5719 Cq-Include-Trybots: luci.dart.try:vm-kernel-precomp-linux-debug-x64-try,vm-kernel-precomp-linux-product-x64-try,vm-kernel-precomp-mac-release-simarm64-try,vm-kernel-precomp-linux-debug-x64c-try,vm-kernel-precomp-obfuscate-linux-release-x64-try Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/195513 Reviewed-by: Daco Harkes <dacoharkes@google.com> Commit-Queue: Tess Strickland <sstrickl@google.com>
2021-04-20 11:17:36 +00:00
inline uint32_t FinalizeHash(uint32_t hash, intptr_t hashbits = kBitsPerInt32) {
hash += hash << 3;
hash ^= hash >> 11; // Logical shift, unsigned hash.
hash += hash << 15;
if (hashbits < kBitsPerInt32) {
hash &= (static_cast<uint32_t>(1) << hashbits) - 1;
}
return (hash == 0) ? 1 : hash;
}
[vm] Initial implementation of deferred loading. (Assignment of libraries to loading units is already done in the kernel generation step.) After compiling and before serializing, we walk the program and for each Code we assign its Instructions, CodeSourceMap and CompressedStackMap to the loading unit of that Code's defining library. Deduplication may cause Instructions, CodeSourceMaps and CompressedStackMaps to belong to more than one loading unit; in this case the objects are assigned to the root loading unit. Later they can be more precisely assigned to the dominating loading unit. All objects except some Instructions, CodeSourceMaps and CompressedStackMaps belong to the root loading unit's snapshot. This snapshot is written like an unsplit snapshot, except that when serializing Code, we will write a reference to a stub or null when the Code's Instructions, CodeSourceMap or CompressedStackMap belongs to a non-root loading unit. The snapshots of non-root loading units contain these deferred objects and references to the corresponding Code objects to patch. The types of objects we defer (Instructions, CodeSourceMaps and CompressedStackMaps) usually represent 70+% of the snapshot size. Bare instructions mode must be disabled when splitting because we cannot have PC-relative calls between loading units. Later we can re-enable this for calls within loading units. Broken: Compactor probably crashes we can now have an unbounded number of image pages and the compactor assumes a fixed number. Embedder's guide: At compile-time, gen_snapshot should be passed --loading_unit_manifest with a path, which will enable splitting and output a mapping from loading unit ids to snapshot output paths. At runtime, sometime during isolate startup, an embedder should call Dart_SetDeferredLoadHandler, probably near an existing call to Dart_SetLibraryTagHandler. The callback is given a loading unit id, and should eventually call Dart_DeferredLoadComplete[Error]. Bug: https://github.com/dart-lang/sdk/issues/41974 Change-Id: Ib597eb87c8cd634416d5ee1f00629c5550aebb00 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/152427 Commit-Queue: Ryan Macnak <rmacnak@google.com> Reviewed-by: Alexander Markov <alexmarkov@google.com>
2020-07-17 19:29:47 +00:00
inline uint32_t HashBytes(const uint8_t* bytes, intptr_t size) {
uint32_t hash = size;
while (size > 0) {
hash = CombineHashes(hash, *bytes);
bytes++;
size--;
}
return hash;
}
} // namespace dart
#endif // RUNTIME_VM_HASH_H_