2018-04-27 17:42:16 +00:00
|
|
|
// 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_
|
|
|
|
|
2019-09-05 21:41:42 +00:00
|
|
|
#include "platform/globals.h"
|
|
|
|
|
2018-04-27 17:42:16 +00:00
|
|
|
namespace dart {
|
|
|
|
|
2019-08-14 15:47:09 +00:00
|
|
|
inline uint32_t CombineHashes(uint32_t hash, uint32_t other_hash) {
|
2018-04-27 17:42:16 +00:00
|
|
|
hash += other_hash;
|
|
|
|
hash += hash << 10;
|
|
|
|
hash ^= hash >> 6; // Logical shift, unsigned hash.
|
|
|
|
return hash;
|
|
|
|
}
|
|
|
|
|
2021-04-20 11:17:36 +00:00
|
|
|
inline uint32_t FinalizeHash(uint32_t hash, intptr_t hashbits = kBitsPerInt32) {
|
2018-04-27 17:42:16 +00:00
|
|
|
hash += hash << 3;
|
|
|
|
hash ^= hash >> 11; // Logical shift, unsigned hash.
|
|
|
|
hash += hash << 15;
|
2022-07-06 12:48:16 +00:00
|
|
|
if (hashbits < kBitsPerInt32) {
|
|
|
|
hash &= (static_cast<uint32_t>(1) << hashbits) - 1;
|
|
|
|
}
|
2018-04-27 17:42:16 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2018-04-27 17:42:16 +00:00
|
|
|
} // namespace dart
|
|
|
|
|
|
|
|
#endif // RUNTIME_VM_HASH_H_
|