2010-03-19 13:51:01 +00:00
|
|
|
// Copyright 2010 the V8 project authors. All rights reserved.
|
2013-03-07 11:12:26 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
|
// met:
|
|
|
|
|
//
|
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
|
// with the distribution.
|
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
|
//
|
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
2010-03-19 13:51:01 +00:00
|
|
|
//
|
|
|
|
|
// Tests of profiles generator and utilities.
|
|
|
|
|
|
2018-04-11 13:09:15 +00:00
|
|
|
#include <limits>
|
|
|
|
|
#include <memory>
|
|
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
#include "include/libplatform/v8-tracing.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "include/v8-profiler.h"
|
2019-05-17 12:13:44 +00:00
|
|
|
#include "src/api/api-inl.h"
|
2014-06-30 13:25:46 +00:00
|
|
|
#include "src/base/platform/platform.h"
|
2019-05-21 09:30:15 +00:00
|
|
|
#include "src/codegen/source-position-table.h"
|
2019-05-20 13:01:00 +00:00
|
|
|
#include "src/deoptimizer/deoptimizer.h"
|
2019-08-19 22:58:21 +00:00
|
|
|
#include "src/heap/spaces.h"
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
#include "src/init/v8.h"
|
2017-07-03 08:23:26 +00:00
|
|
|
#include "src/libplatform/default-platform.h"
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
#include "src/libplatform/tracing/trace-event-listener.h"
|
2020-04-25 19:00:16 +00:00
|
|
|
#include "src/libsampler/sampler.h"
|
2019-05-20 09:15:06 +00:00
|
|
|
#include "src/logging/log.h"
|
2019-05-23 08:51:46 +00:00
|
|
|
#include "src/objects/objects-inl.h"
|
2015-09-28 19:34:08 +00:00
|
|
|
#include "src/profiler/cpu-profiler-inl.h"
|
2016-06-22 16:43:46 +00:00
|
|
|
#include "src/profiler/profiler-listener.h"
|
2019-02-07 22:52:20 +00:00
|
|
|
#include "src/profiler/tracing-cpu-profiler.h"
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
#include "src/tracing/trace-event.h"
|
2019-05-23 13:27:57 +00:00
|
|
|
#include "src/utils/utils.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "test/cctest/cctest.h"
|
2019-08-19 22:58:21 +00:00
|
|
|
#include "test/cctest/heap/heap-utils.h"
|
2014-06-03 08:12:43 +00:00
|
|
|
#include "test/cctest/profiler-extension.h"
|
2016-06-15 09:59:00 +00:00
|
|
|
|
2019-08-05 14:57:31 +00:00
|
|
|
#ifdef V8_USE_PERFETTO
|
2019-09-06 13:12:37 +00:00
|
|
|
#include "protos/perfetto/trace/trace.pb.h"
|
2019-08-05 14:57:31 +00:00
|
|
|
#endif
|
|
|
|
|
|
2017-09-30 13:19:52 +00:00
|
|
|
namespace v8 {
|
|
|
|
|
namespace internal {
|
|
|
|
|
namespace test_cpu_profiler {
|
2010-03-19 13:51:01 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
// Helper methods
|
2015-12-08 18:44:23 +00:00
|
|
|
static v8::Local<v8::Function> GetFunction(v8::Local<v8::Context> env,
|
|
|
|
|
const char* name) {
|
|
|
|
|
return v8::Local<v8::Function>::Cast(
|
|
|
|
|
env->Global()->Get(env, v8_str(name)).ToLocalChecked());
|
2015-02-06 16:50:56 +00:00
|
|
|
}
|
|
|
|
|
|
2015-04-08 16:13:24 +00:00
|
|
|
static size_t offset(const char* src, const char* substring) {
|
|
|
|
|
const char* it = strstr(src, substring);
|
|
|
|
|
CHECK(it);
|
|
|
|
|
return static_cast<size_t>(it - src);
|
2015-03-24 12:46:13 +00:00
|
|
|
}
|
|
|
|
|
|
2016-11-22 10:14:36 +00:00
|
|
|
template <typename A, typename B>
|
|
|
|
|
static int dist(A a, B b) {
|
|
|
|
|
return abs(static_cast<int>(a) - static_cast<int>(b));
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-18 09:23:28 +00:00
|
|
|
static const char* reason(const i::DeoptimizeReason reason) {
|
|
|
|
|
return i::DeoptimizeReasonToString(reason);
|
2015-03-05 10:37:56 +00:00
|
|
|
}
|
|
|
|
|
|
2010-03-19 13:51:01 +00:00
|
|
|
TEST(StartStop) {
|
2016-10-28 20:17:44 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
CpuProfilesCollection profiles(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator generator(&profiles, code_observer.code_map());
|
2016-06-15 09:59:00 +00:00
|
|
|
std::unique_ptr<ProfilerEventsProcessor> processor(
|
2019-07-18 23:18:18 +00:00
|
|
|
new SamplingEventsProcessor(isolate, &generator, &code_observer,
|
2019-03-14 07:25:55 +00:00
|
|
|
v8::base::TimeDelta::FromMicroseconds(100),
|
|
|
|
|
true));
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2013-08-23 10:59:29 +00:00
|
|
|
processor->StopSynchronously();
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
|
|
|
|
|
2012-11-30 10:26:21 +00:00
|
|
|
static void EnqueueTickSampleEvent(ProfilerEventsProcessor* proc,
|
|
|
|
|
i::Address frame1,
|
2018-04-13 22:28:05 +00:00
|
|
|
i::Address frame2 = kNullAddress,
|
|
|
|
|
i::Address frame3 = kNullAddress) {
|
2018-10-16 13:40:25 +00:00
|
|
|
v8::internal::TickSample sample;
|
|
|
|
|
sample.pc = reinterpret_cast<void*>(frame1);
|
|
|
|
|
sample.tos = reinterpret_cast<void*>(frame1);
|
|
|
|
|
sample.frames_count = 0;
|
2018-04-13 22:28:05 +00:00
|
|
|
if (frame2 != kNullAddress) {
|
2018-10-16 13:40:25 +00:00
|
|
|
sample.stack[0] = reinterpret_cast<void*>(frame2);
|
|
|
|
|
sample.frames_count = 1;
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
2018-04-13 22:28:05 +00:00
|
|
|
if (frame3 != kNullAddress) {
|
2018-10-16 13:40:25 +00:00
|
|
|
sample.stack[1] = reinterpret_cast<void*>(frame3);
|
|
|
|
|
sample.frames_count = 2;
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
2018-10-16 13:40:25 +00:00
|
|
|
sample.timestamp = base::TimeTicks::HighResolutionNow();
|
|
|
|
|
proc->AddSample(sample);
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
|
|
|
|
|
2010-04-12 07:23:43 +00:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
|
|
class TestSetup {
|
|
|
|
|
public:
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
TestSetup() : old_flag_prof_browser_mode_(i::FLAG_prof_browser_mode) {
|
2010-04-12 07:23:43 +00:00
|
|
|
i::FLAG_prof_browser_mode = false;
|
|
|
|
|
}
|
|
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
~TestSetup() { i::FLAG_prof_browser_mode = old_flag_prof_browser_mode_; }
|
2010-04-12 07:23:43 +00:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
bool old_flag_prof_browser_mode_;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
|
2018-11-25 03:47:59 +00:00
|
|
|
i::AbstractCode CreateCode(LocalContext* env) {
|
2013-07-01 10:12:03 +00:00
|
|
|
static int counter = 0;
|
|
|
|
|
i::EmbeddedVector<char, 256> script;
|
|
|
|
|
i::EmbeddedVector<char, 32> name;
|
|
|
|
|
|
2014-06-13 16:43:27 +00:00
|
|
|
i::SNPrintF(name, "function_%d", ++counter);
|
2019-04-29 11:06:49 +00:00
|
|
|
const char* name_start = name.begin();
|
2014-06-13 16:43:27 +00:00
|
|
|
i::SNPrintF(script,
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
"function %s() {\n"
|
|
|
|
|
"var counter = 0;\n"
|
|
|
|
|
"for (var i = 0; i < %d; ++i) counter += i;\n"
|
|
|
|
|
"return '%s_' + counter;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"%s();\n",
|
|
|
|
|
name_start, counter, name_start, name_start);
|
2019-04-29 11:06:49 +00:00
|
|
|
CompileRun(script.begin());
|
2015-02-06 16:50:56 +00:00
|
|
|
|
2015-10-23 12:26:49 +00:00
|
|
|
i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Utils::OpenHandle(*GetFunction(env->local(), name_start)));
|
2016-02-26 11:04:04 +00:00
|
|
|
return fun->abstract_code();
|
2013-07-01 10:12:03 +00:00
|
|
|
}
|
|
|
|
|
|
2010-03-19 13:51:01 +00:00
|
|
|
TEST(CodeEvents) {
|
2013-04-10 08:29:39 +00:00
|
|
|
CcTest::InitializeVM();
|
2013-07-01 10:12:03 +00:00
|
|
|
LocalContext env;
|
2013-09-19 09:17:13 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
2013-02-15 09:27:10 +00:00
|
|
|
i::Factory* factory = isolate->factory();
|
2010-04-12 07:23:43 +00:00
|
|
|
TestSetup test_setup;
|
2013-07-01 10:12:03 +00:00
|
|
|
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
2019-12-20 10:54:21 +00:00
|
|
|
i::Handle<i::AbstractCode> aaa_code(CreateCode(&env), isolate);
|
|
|
|
|
i::Handle<i::AbstractCode> comment_code(CreateCode(&env), isolate);
|
|
|
|
|
i::Handle<i::AbstractCode> comment2_code(CreateCode(&env), isolate);
|
|
|
|
|
i::Handle<i::AbstractCode> moved_code(CreateCode(&env), isolate);
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2016-06-15 09:59:00 +00:00
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
2018-10-16 13:40:25 +00:00
|
|
|
ProfilerEventsProcessor* processor = new SamplingEventsProcessor(
|
2019-07-18 23:18:18 +00:00
|
|
|
isolate, generator, &code_observer,
|
|
|
|
|
v8::base::TimeDelta::FromMicroseconds(100), true);
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2018-10-17 12:09:34 +00:00
|
|
|
ProfilerListener profiler_listener(isolate, processor);
|
2018-05-04 00:19:12 +00:00
|
|
|
isolate->logger()->AddCodeEventListener(&profiler_listener);
|
2010-03-19 13:51:01 +00:00
|
|
|
|
|
|
|
|
// Enqueue code creation events.
|
|
|
|
|
const char* aaa_str = "aaa";
|
2014-04-17 13:27:02 +00:00
|
|
|
i::Handle<i::String> aaa_name = factory->NewStringFromAsciiChecked(aaa_str);
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::FUNCTION_TAG, aaa_code,
|
2019-12-20 10:54:21 +00:00
|
|
|
aaa_name);
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment_code,
|
|
|
|
|
"comment");
|
|
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, comment2_code,
|
|
|
|
|
"comment2");
|
2019-12-20 10:54:21 +00:00
|
|
|
profiler_listener.CodeMoveEvent(*comment2_code, *moved_code);
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2012-11-30 10:26:21 +00:00
|
|
|
// Enqueue a tick event to enable code events processing.
|
2019-12-20 10:54:21 +00:00
|
|
|
EnqueueTickSampleEvent(processor, aaa_code->InstructionStart());
|
2010-03-19 13:51:01 +00:00
|
|
|
|
2018-05-04 00:19:12 +00:00
|
|
|
isolate->logger()->RemoveCodeEventListener(&profiler_listener);
|
2013-08-23 10:59:29 +00:00
|
|
|
processor->StopSynchronously();
|
2010-03-19 13:51:01 +00:00
|
|
|
|
|
|
|
|
// Check the state of profile generator.
|
2018-07-27 09:08:25 +00:00
|
|
|
CodeEntry* aaa =
|
2019-12-20 10:54:21 +00:00
|
|
|
generator->code_map()->FindEntry(aaa_code->InstructionStart());
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(aaa);
|
2015-02-06 16:50:56 +00:00
|
|
|
CHECK_EQ(0, strcmp(aaa_str, aaa->name()));
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2016-06-15 09:59:00 +00:00
|
|
|
CodeEntry* comment =
|
2019-12-20 10:54:21 +00:00
|
|
|
generator->code_map()->FindEntry(comment_code->InstructionStart());
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(comment);
|
2015-01-30 09:48:50 +00:00
|
|
|
CHECK_EQ(0, strcmp("comment", comment->name()));
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2019-12-20 10:54:21 +00:00
|
|
|
CHECK(!generator->code_map()->FindEntry(comment2_code->InstructionStart()));
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2018-07-27 09:08:25 +00:00
|
|
|
CodeEntry* comment2 =
|
2019-12-20 10:54:21 +00:00
|
|
|
generator->code_map()->FindEntry(moved_code->InstructionStart());
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(comment2);
|
2015-01-30 09:48:50 +00:00
|
|
|
CHECK_EQ(0, strcmp("comment2", comment2->name()));
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
|
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
template <typename T>
|
2010-03-19 13:51:01 +00:00
|
|
|
static int CompareProfileNodes(const T* p1, const T* p2) {
|
|
|
|
|
return strcmp((*p1)->entry()->name(), (*p2)->entry()->name());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(TickEvents) {
|
2010-04-12 07:23:43 +00:00
|
|
|
TestSetup test_setup;
|
2013-07-01 10:12:03 +00:00
|
|
|
LocalContext env;
|
2013-09-19 09:17:13 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
2013-07-01 10:12:03 +00:00
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
2019-12-20 10:54:21 +00:00
|
|
|
i::Handle<i::AbstractCode> frame1_code(CreateCode(&env), isolate);
|
|
|
|
|
i::Handle<i::AbstractCode> frame2_code(CreateCode(&env), isolate);
|
|
|
|
|
i::Handle<i::AbstractCode> frame3_code(CreateCode(&env), isolate);
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2016-06-15 09:59:00 +00:00
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
2019-03-14 07:25:55 +00:00
|
|
|
ProfilerEventsProcessor* processor = new SamplingEventsProcessor(
|
2019-07-18 23:18:18 +00:00
|
|
|
CcTest::i_isolate(), generator, &code_observer,
|
2019-03-14 07:25:55 +00:00
|
|
|
v8::base::TimeDelta::FromMicroseconds(100), true);
|
2019-07-18 23:18:18 +00:00
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-09 19:20:21 +00:00
|
|
|
profiles->StartProfiling("");
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2018-10-17 12:09:34 +00:00
|
|
|
ProfilerListener profiler_listener(isolate, processor);
|
2018-05-04 00:19:12 +00:00
|
|
|
isolate->logger()->AddCodeEventListener(&profiler_listener);
|
2010-03-19 13:51:01 +00:00
|
|
|
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame1_code, "bbb");
|
2017-10-19 11:25:59 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::STUB_TAG, frame2_code, "ccc");
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, frame3_code, "ddd");
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2019-12-20 10:54:21 +00:00
|
|
|
EnqueueTickSampleEvent(processor, frame1_code->raw_instruction_start());
|
2013-07-01 10:12:03 +00:00
|
|
|
EnqueueTickSampleEvent(
|
2016-06-15 09:59:00 +00:00
|
|
|
processor,
|
2019-12-20 10:54:21 +00:00
|
|
|
frame2_code->raw_instruction_start() + frame2_code->ExecutableSize() / 2,
|
|
|
|
|
frame1_code->raw_instruction_start() + frame1_code->ExecutableSize() / 2);
|
|
|
|
|
EnqueueTickSampleEvent(processor, frame3_code->raw_instruction_end() - 1,
|
|
|
|
|
frame2_code->raw_instruction_end() - 1,
|
|
|
|
|
frame1_code->raw_instruction_end() - 1);
|
2010-03-19 13:51:01 +00:00
|
|
|
|
2018-05-04 00:19:12 +00:00
|
|
|
isolate->logger()->RemoveCodeEventListener(&profiler_listener);
|
2013-08-23 10:59:29 +00:00
|
|
|
processor->StopSynchronously();
|
2013-07-30 07:01:16 +00:00
|
|
|
CpuProfile* profile = profiles->StopProfiling("");
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2010-03-19 13:51:01 +00:00
|
|
|
|
|
|
|
|
// Check call trees.
|
2017-08-29 12:40:31 +00:00
|
|
|
const std::vector<ProfileNode*>* top_down_root_children =
|
2010-03-30 11:38:39 +00:00
|
|
|
profile->top_down()->root()->children();
|
2017-08-29 12:40:31 +00:00
|
|
|
CHECK_EQ(1, top_down_root_children->size());
|
|
|
|
|
CHECK_EQ(0, strcmp("bbb", top_down_root_children->back()->entry()->name()));
|
|
|
|
|
const std::vector<ProfileNode*>* top_down_bbb_children =
|
|
|
|
|
top_down_root_children->back()->children();
|
|
|
|
|
CHECK_EQ(1, top_down_bbb_children->size());
|
2017-10-19 11:25:59 +00:00
|
|
|
CHECK_EQ(0, strcmp("ccc", top_down_bbb_children->back()->entry()->name()));
|
2017-08-29 12:40:31 +00:00
|
|
|
const std::vector<ProfileNode*>* top_down_stub_children =
|
|
|
|
|
top_down_bbb_children->back()->children();
|
|
|
|
|
CHECK_EQ(1, top_down_stub_children->size());
|
|
|
|
|
CHECK_EQ(0, strcmp("ddd", top_down_stub_children->back()->entry()->name()));
|
|
|
|
|
const std::vector<ProfileNode*>* top_down_ddd_children =
|
|
|
|
|
top_down_stub_children->back()->children();
|
|
|
|
|
CHECK(top_down_ddd_children->empty());
|
2010-03-19 13:51:01 +00:00
|
|
|
}
|
2010-03-30 11:38:39 +00:00
|
|
|
|
2010-08-10 12:06:42 +00:00
|
|
|
// http://crbug/51594
|
|
|
|
|
// This test must not crash.
|
|
|
|
|
TEST(CrashIfStoppingLastNonExistentProfile) {
|
2013-04-10 08:29:39 +00:00
|
|
|
CcTest::InitializeVM();
|
2010-08-10 12:06:42 +00:00
|
|
|
TestSetup test_setup;
|
2016-07-08 15:00:23 +00:00
|
|
|
std::unique_ptr<CpuProfiler> profiler(new CpuProfiler(CcTest::i_isolate()));
|
2013-04-02 07:53:50 +00:00
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StopProfiling("2");
|
|
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StopProfiling("");
|
2010-08-10 12:06:42 +00:00
|
|
|
}
|
|
|
|
|
|
2011-05-19 08:25:38 +00:00
|
|
|
// http://code.google.com/p/v8/issues/detail?id=1398
|
|
|
|
|
// Long stacks (exceeding max frames limit) must not be erased.
|
|
|
|
|
TEST(Issue1398) {
|
|
|
|
|
TestSetup test_setup;
|
2013-07-01 10:12:03 +00:00
|
|
|
LocalContext env;
|
2013-09-19 09:17:13 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
2013-07-01 10:12:03 +00:00
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
2019-12-20 10:54:21 +00:00
|
|
|
i::Handle<i::AbstractCode> code(CreateCode(&env), isolate);
|
2013-07-01 10:12:03 +00:00
|
|
|
|
2016-06-15 09:59:00 +00:00
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
2019-03-14 07:25:55 +00:00
|
|
|
ProfilerEventsProcessor* processor = new SamplingEventsProcessor(
|
2019-07-18 23:18:18 +00:00
|
|
|
CcTest::i_isolate(), generator, &code_observer,
|
2019-03-14 07:25:55 +00:00
|
|
|
v8::base::TimeDelta::FromMicroseconds(100), true);
|
2019-07-18 23:18:18 +00:00
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-09 19:20:21 +00:00
|
|
|
profiles->StartProfiling("");
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2018-10-17 12:09:34 +00:00
|
|
|
ProfilerListener profiler_listener(isolate, processor);
|
2011-05-19 08:25:38 +00:00
|
|
|
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::BUILTIN_TAG, code, "bbb");
|
2011-05-19 08:25:38 +00:00
|
|
|
|
2018-10-16 13:40:25 +00:00
|
|
|
v8::internal::TickSample sample;
|
2019-12-20 10:54:21 +00:00
|
|
|
sample.pc = reinterpret_cast<void*>(code->InstructionStart());
|
2018-10-16 13:40:25 +00:00
|
|
|
sample.tos = nullptr;
|
2019-08-21 15:22:17 +00:00
|
|
|
sample.frames_count = TickSample::kMaxFramesCount;
|
2018-10-16 13:40:25 +00:00
|
|
|
for (unsigned i = 0; i < sample.frames_count; ++i) {
|
2019-12-20 10:54:21 +00:00
|
|
|
sample.stack[i] = reinterpret_cast<void*>(code->InstructionStart());
|
2011-05-19 08:25:38 +00:00
|
|
|
}
|
2018-10-16 13:40:25 +00:00
|
|
|
sample.timestamp = base::TimeTicks::HighResolutionNow();
|
|
|
|
|
processor->AddSample(sample);
|
2011-05-19 08:25:38 +00:00
|
|
|
|
2013-08-23 10:59:29 +00:00
|
|
|
processor->StopSynchronously();
|
2013-07-30 07:01:16 +00:00
|
|
|
CpuProfile* profile = profiles->StopProfiling("");
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2011-05-19 08:25:38 +00:00
|
|
|
|
2015-01-30 09:29:25 +00:00
|
|
|
unsigned actual_depth = 0;
|
2011-05-19 08:25:38 +00:00
|
|
|
const ProfileNode* node = profile->top_down()->root();
|
2017-08-29 12:40:31 +00:00
|
|
|
while (!node->children()->empty()) {
|
|
|
|
|
node = node->children()->back();
|
2011-05-19 08:25:38 +00:00
|
|
|
++actual_depth;
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-21 15:22:17 +00:00
|
|
|
CHECK_EQ(1 + TickSample::kMaxFramesCount, actual_depth); // +1 for PC.
|
2011-05-19 08:25:38 +00:00
|
|
|
}
|
|
|
|
|
|
2011-03-22 16:10:01 +00:00
|
|
|
TEST(DeleteAllCpuProfiles) {
|
2013-04-10 08:29:39 +00:00
|
|
|
CcTest::InitializeVM();
|
2011-03-22 16:10:01 +00:00
|
|
|
TestSetup test_setup;
|
2016-07-08 15:00:23 +00:00
|
|
|
std::unique_ptr<CpuProfiler> profiler(new CpuProfiler(CcTest::i_isolate()));
|
2013-04-02 07:53:50 +00:00
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
|
|
|
|
profiler->DeleteAllProfiles();
|
|
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
|
|
|
|
|
|
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StopProfiling("1");
|
|
|
|
|
CHECK_EQ(1, profiler->GetProfilesCount());
|
|
|
|
|
profiler->DeleteAllProfiles();
|
|
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
|
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StartProfiling("2");
|
|
|
|
|
profiler->StopProfiling("2");
|
|
|
|
|
profiler->StopProfiling("1");
|
|
|
|
|
CHECK_EQ(2, profiler->GetProfilesCount());
|
|
|
|
|
profiler->DeleteAllProfiles();
|
|
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
2011-03-22 16:10:01 +00:00
|
|
|
|
|
|
|
|
// Test profiling cancellation by the 'delete' command.
|
2013-04-02 07:53:50 +00:00
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StartProfiling("2");
|
|
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
|
|
|
|
profiler->DeleteAllProfiles();
|
|
|
|
|
CHECK_EQ(0, profiler->GetProfilesCount());
|
2011-03-22 16:10:01 +00:00
|
|
|
}
|
|
|
|
|
|
2013-12-18 08:59:09 +00:00
|
|
|
static bool FindCpuProfile(v8::CpuProfiler* v8profiler,
|
|
|
|
|
const v8::CpuProfile* v8profile) {
|
|
|
|
|
i::CpuProfiler* profiler = reinterpret_cast<i::CpuProfiler*>(v8profiler);
|
|
|
|
|
const i::CpuProfile* profile =
|
|
|
|
|
reinterpret_cast<const i::CpuProfile*>(v8profile);
|
|
|
|
|
int length = profiler->GetProfilesCount();
|
2013-05-28 08:00:16 +00:00
|
|
|
for (int i = 0; i < length; i++) {
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
if (profile == profiler->GetProfile(i)) return true;
|
2013-05-28 08:00:16 +00:00
|
|
|
}
|
2013-12-18 08:59:09 +00:00
|
|
|
return false;
|
2013-05-28 08:00:16 +00:00
|
|
|
}
|
|
|
|
|
|
2011-03-22 16:10:01 +00:00
|
|
|
TEST(DeleteCpuProfile) {
|
|
|
|
|
LocalContext env;
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfiler* cpu_profiler = v8::CpuProfiler::New(env->GetIsolate());
|
2013-12-18 08:59:09 +00:00
|
|
|
i::CpuProfiler* iprofiler = reinterpret_cast<i::CpuProfiler*>(cpu_profiler);
|
2011-03-22 16:10:01 +00:00
|
|
|
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> name1 = v8_str("1");
|
2014-03-28 09:24:49 +00:00
|
|
|
cpu_profiler->StartProfiling(name1);
|
|
|
|
|
v8::CpuProfile* p1 = cpu_profiler->StopProfiling(name1);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(p1);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(1, iprofiler->GetProfilesCount());
|
|
|
|
|
CHECK(FindCpuProfile(cpu_profiler, p1));
|
2014-03-28 09:24:49 +00:00
|
|
|
p1->Delete();
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2011-03-22 16:10:01 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> name2 = v8_str("2");
|
2014-03-28 09:24:49 +00:00
|
|
|
cpu_profiler->StartProfiling(name2);
|
|
|
|
|
v8::CpuProfile* p2 = cpu_profiler->StopProfiling(name2);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(p2);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(1, iprofiler->GetProfilesCount());
|
|
|
|
|
CHECK(FindCpuProfile(cpu_profiler, p2));
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> name3 = v8_str("3");
|
2014-03-28 09:24:49 +00:00
|
|
|
cpu_profiler->StartProfiling(name3);
|
|
|
|
|
v8::CpuProfile* p3 = cpu_profiler->StopProfiling(name3);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(p3);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(2, iprofiler->GetProfilesCount());
|
|
|
|
|
CHECK_NE(p2, p3);
|
|
|
|
|
CHECK(FindCpuProfile(cpu_profiler, p3));
|
|
|
|
|
CHECK(FindCpuProfile(cpu_profiler, p2));
|
2014-03-28 09:24:49 +00:00
|
|
|
p2->Delete();
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(1, iprofiler->GetProfilesCount());
|
|
|
|
|
CHECK(!FindCpuProfile(cpu_profiler, p2));
|
|
|
|
|
CHECK(FindCpuProfile(cpu_profiler, p3));
|
2014-03-28 09:24:49 +00:00
|
|
|
p3->Delete();
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2016-07-08 15:00:23 +00:00
|
|
|
cpu_profiler->Dispose();
|
2011-03-22 16:10:01 +00:00
|
|
|
}
|
|
|
|
|
|
2013-08-05 07:17:08 +00:00
|
|
|
TEST(ProfileStartEndTime) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfiler* cpu_profiler = v8::CpuProfiler::New(env->GetIsolate());
|
2013-08-05 07:17:08 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> profile_name = v8_str("test");
|
2014-03-28 09:24:49 +00:00
|
|
|
cpu_profiler->StartProfiling(profile_name);
|
|
|
|
|
const v8::CpuProfile* profile = cpu_profiler->StopProfiling(profile_name);
|
2013-08-05 07:17:08 +00:00
|
|
|
CHECK(profile->GetStartTime() <= profile->GetEndTime());
|
2016-07-08 15:00:23 +00:00
|
|
|
cpu_profiler->Dispose();
|
2013-08-05 07:17:08 +00:00
|
|
|
}
|
|
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
class ProfilerHelper {
|
|
|
|
|
public:
|
|
|
|
|
explicit ProfilerHelper(const v8::Local<v8::Context>& context)
|
|
|
|
|
: context_(context),
|
|
|
|
|
profiler_(v8::CpuProfiler::New(context->GetIsolate())) {
|
|
|
|
|
i::ProfilerExtension::set_profiler(profiler_);
|
|
|
|
|
}
|
|
|
|
|
~ProfilerHelper() {
|
|
|
|
|
i::ProfilerExtension::set_profiler(static_cast<CpuProfiler*>(nullptr));
|
|
|
|
|
profiler_->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-27 11:31:49 +00:00
|
|
|
using ProfilingMode = v8::CpuProfilingMode;
|
2018-05-23 08:26:10 +00:00
|
|
|
|
2019-05-09 19:20:21 +00:00
|
|
|
v8::CpuProfile* Run(
|
|
|
|
|
v8::Local<v8::Function> function, v8::Local<v8::Value> argv[], int argc,
|
|
|
|
|
unsigned min_js_samples = 0, unsigned min_external_samples = 0,
|
|
|
|
|
ProfilingMode mode = ProfilingMode::kLeafNodeLineNumbers,
|
2019-08-19 22:58:21 +00:00
|
|
|
unsigned max_samples = v8::CpuProfilingOptions::kNoSampleLimit,
|
|
|
|
|
v8::Local<v8::Context> context = v8::Local<v8::Context>());
|
2016-07-08 15:00:23 +00:00
|
|
|
|
|
|
|
|
v8::CpuProfiler* profiler() { return profiler_; }
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
v8::Local<v8::Context> context_;
|
|
|
|
|
v8::CpuProfiler* profiler_;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
v8::CpuProfile* ProfilerHelper::Run(v8::Local<v8::Function> function,
|
|
|
|
|
v8::Local<v8::Value> argv[], int argc,
|
|
|
|
|
unsigned min_js_samples,
|
|
|
|
|
unsigned min_external_samples,
|
2019-08-19 22:58:21 +00:00
|
|
|
ProfilingMode mode, unsigned max_samples,
|
|
|
|
|
v8::Local<v8::Context> context) {
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> profile_name = v8_str("my_profile");
|
2013-07-10 12:56:58 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
profiler_->SetSamplingInterval(100);
|
2019-08-19 22:58:21 +00:00
|
|
|
profiler_->StartProfiling(profile_name, {mode, max_samples, 0, context});
|
2013-07-10 12:56:58 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::internal::CpuProfiler* iprofiler =
|
|
|
|
|
reinterpret_cast<v8::internal::CpuProfiler*>(profiler_);
|
2018-10-16 13:40:25 +00:00
|
|
|
v8::sampler::Sampler* sampler =
|
|
|
|
|
reinterpret_cast<i::SamplingEventsProcessor*>(iprofiler->processor())
|
|
|
|
|
->sampler();
|
2013-07-10 12:56:58 +00:00
|
|
|
sampler->StartCountingSamples();
|
2019-08-19 22:58:21 +00:00
|
|
|
|
2013-07-10 12:56:58 +00:00
|
|
|
do {
|
2016-07-08 15:00:23 +00:00
|
|
|
function->Call(context_, context_->Global(), argc, argv).ToLocalChecked();
|
2016-02-12 16:02:29 +00:00
|
|
|
} while (sampler->js_sample_count() < min_js_samples ||
|
|
|
|
|
sampler->external_sample_count() < min_external_samples);
|
2013-07-10 12:56:58 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = profiler_->StopProfiling(profile_name);
|
2013-07-10 12:56:58 +00:00
|
|
|
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2013-07-10 12:56:58 +00:00
|
|
|
// Dump collected profile to have a better diagnostic in case of failure.
|
2014-03-28 09:24:49 +00:00
|
|
|
reinterpret_cast<i::CpuProfile*>(profile)->Print();
|
2013-07-10 12:56:58 +00:00
|
|
|
|
|
|
|
|
return profile;
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-12 22:19:44 +00:00
|
|
|
static unsigned TotalHitCount(const v8::CpuProfileNode* node) {
|
|
|
|
|
unsigned hit_count = node->GetHitCount();
|
|
|
|
|
for (int i = 0, count = node->GetChildrenCount(); i < count; ++i)
|
|
|
|
|
hit_count += TotalHitCount(node->GetChild(i));
|
|
|
|
|
return hit_count;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
static const v8::CpuProfileNode* FindChild(v8::Local<v8::Context> context,
|
|
|
|
|
const v8::CpuProfileNode* node,
|
2013-04-10 09:47:44 +00:00
|
|
|
const char* name) {
|
|
|
|
|
int count = node->GetChildrenCount();
|
2016-02-08 18:12:04 +00:00
|
|
|
v8::Local<v8::String> name_handle = v8_str(name);
|
2013-04-10 09:47:44 +00:00
|
|
|
for (int i = 0; i < count; i++) {
|
|
|
|
|
const v8::CpuProfileNode* child = node->GetChild(i);
|
2016-02-08 18:12:04 +00:00
|
|
|
if (name_handle->Equals(context, child->GetFunctionName()).FromJust()) {
|
2015-12-08 18:44:23 +00:00
|
|
|
return child;
|
|
|
|
|
}
|
2013-04-10 09:47:44 +00:00
|
|
|
}
|
2017-10-13 16:33:03 +00:00
|
|
|
return nullptr;
|
2013-04-10 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-12 22:19:44 +00:00
|
|
|
static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node,
|
|
|
|
|
const char* name) {
|
|
|
|
|
for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {
|
|
|
|
|
const v8::CpuProfileNode* child = node->GetChild(i);
|
|
|
|
|
if (strcmp(child->GetFunctionNameStr(), name) == 0) {
|
|
|
|
|
return child;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
2013-04-10 09:47:44 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
static const v8::CpuProfileNode* GetChild(v8::Local<v8::Context> context,
|
|
|
|
|
const v8::CpuProfileNode* node,
|
2013-05-24 16:19:06 +00:00
|
|
|
const char* name) {
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* result = FindChild(context, node, name);
|
2017-12-18 16:19:23 +00:00
|
|
|
if (!result) FATAL("Failed to GetChild: %s", name);
|
2013-05-24 16:19:06 +00:00
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
static void CheckSimpleBranch(v8::Local<v8::Context> context,
|
|
|
|
|
const v8::CpuProfileNode* node,
|
2013-04-10 09:47:44 +00:00
|
|
|
const char* names[], int length) {
|
|
|
|
|
for (int i = 0; i < length; i++) {
|
|
|
|
|
const char* name = names[i];
|
2015-12-08 18:44:23 +00:00
|
|
|
node = GetChild(context, node, name);
|
2013-04-10 09:47:44 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
static const ProfileNode* GetSimpleBranch(v8::Local<v8::Context> context,
|
|
|
|
|
v8::CpuProfile* profile,
|
2015-03-05 10:37:56 +00:00
|
|
|
const char* names[], int length) {
|
|
|
|
|
const v8::CpuProfileNode* node = profile->GetTopDownRoot();
|
2015-02-10 14:32:42 +00:00
|
|
|
for (int i = 0; i < length; i++) {
|
2015-12-08 18:44:23 +00:00
|
|
|
node = GetChild(context, node, names[i]);
|
2015-02-10 14:32:42 +00:00
|
|
|
}
|
2015-03-05 10:37:56 +00:00
|
|
|
return reinterpret_cast<const ProfileNode*>(node);
|
2015-02-10 14:32:42 +00:00
|
|
|
}
|
|
|
|
|
|
2018-05-23 08:26:10 +00:00
|
|
|
struct NameLinePair {
|
|
|
|
|
const char* name;
|
|
|
|
|
int line_number;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
static const v8::CpuProfileNode* FindChild(const v8::CpuProfileNode* node,
|
|
|
|
|
NameLinePair pair) {
|
|
|
|
|
for (int i = 0, count = node->GetChildrenCount(); i < count; ++i) {
|
|
|
|
|
const v8::CpuProfileNode* child = node->GetChild(i);
|
|
|
|
|
// The name and line number must match, or if the requested line number was
|
|
|
|
|
// -1, then match any function of the same name.
|
|
|
|
|
if (strcmp(child->GetFunctionNameStr(), pair.name) == 0 &&
|
|
|
|
|
(child->GetLineNumber() == pair.line_number ||
|
|
|
|
|
pair.line_number == -1)) {
|
|
|
|
|
return child;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return nullptr;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const v8::CpuProfileNode* GetChild(const v8::CpuProfileNode* node,
|
|
|
|
|
NameLinePair pair) {
|
|
|
|
|
const v8::CpuProfileNode* result = FindChild(node, pair);
|
|
|
|
|
if (!result) FATAL("Failed to GetChild: %s:%d", pair.name, pair.line_number);
|
|
|
|
|
return result;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void CheckBranch(const v8::CpuProfileNode* node, NameLinePair path[],
|
|
|
|
|
int length) {
|
|
|
|
|
for (int i = 0; i < length; i++) {
|
|
|
|
|
NameLinePair pair = path[i];
|
|
|
|
|
node = GetChild(node, pair);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
static const char* cpu_profiler_test_source =
|
|
|
|
|
"%NeverOptimizeFunction(loop);\n"
|
|
|
|
|
"%NeverOptimizeFunction(delay);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(baz);\n"
|
|
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function loop(timeout) {\n"
|
|
|
|
|
" this.mmm = 0;\n"
|
|
|
|
|
" var start = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" var n = 1000;\n"
|
|
|
|
|
" while(n > 1) {\n"
|
|
|
|
|
" n--;\n"
|
|
|
|
|
" this.mmm += n * n * n;\n"
|
|
|
|
|
" }\n"
|
|
|
|
|
" } while (Date.now() - start < timeout);\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function delay() { loop(10); }\n"
|
|
|
|
|
"function bar() { delay(); }\n"
|
|
|
|
|
"function baz() { delay(); }\n"
|
|
|
|
|
"function foo() {\n"
|
|
|
|
|
" delay();\n"
|
|
|
|
|
" bar();\n"
|
|
|
|
|
" delay();\n"
|
|
|
|
|
" baz();\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start(duration) {\n"
|
|
|
|
|
" var start = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" foo();\n"
|
|
|
|
|
" } while (Date.now() - start < duration);\n"
|
|
|
|
|
"}\n";
|
2013-04-10 09:47:44 +00:00
|
|
|
|
|
|
|
|
// Check that the profile tree for the script above will look like the
|
|
|
|
|
// following:
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 1062 0 (root) [-1]
|
|
|
|
|
// 1054 0 start [-1]
|
|
|
|
|
// 1054 1 foo [-1]
|
|
|
|
|
// 265 0 baz [-1]
|
|
|
|
|
// 265 1 delay [-1]
|
|
|
|
|
// 264 264 loop [-1]
|
|
|
|
|
// 525 3 delay [-1]
|
|
|
|
|
// 522 522 loop [-1]
|
|
|
|
|
// 263 0 bar [-1]
|
|
|
|
|
// 263 1 delay [-1]
|
|
|
|
|
// 262 262 loop [-1]
|
|
|
|
|
// 2 2 (program) [-1]
|
|
|
|
|
// 6 6 (garbage collector) [-1]
|
|
|
|
|
TEST(CollectCpuProfile) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2013-04-10 09:47:44 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(cpu_profiler_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-04-10 09:47:44 +00:00
|
|
|
|
2013-04-15 14:45:38 +00:00
|
|
|
int32_t profiling_interval_ms = 200;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), profiling_interval_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 1000);
|
2013-04-10 09:47:44 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
const v8::CpuProfileNode* foo_node = GetChild(env.local(), start_node, "foo");
|
2013-04-10 09:47:44 +00:00
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
const char* bar_branch[] = {"bar", "delay", "loop"};
|
|
|
|
|
CheckSimpleBranch(env.local(), foo_node, bar_branch, arraysize(bar_branch));
|
|
|
|
|
const char* baz_branch[] = {"baz", "delay", "loop"};
|
|
|
|
|
CheckSimpleBranch(env.local(), foo_node, baz_branch, arraysize(baz_branch));
|
|
|
|
|
const char* delay_branch[] = {"delay", "loop"};
|
|
|
|
|
CheckSimpleBranch(env.local(), foo_node, delay_branch,
|
|
|
|
|
arraysize(delay_branch));
|
2013-04-10 14:31:13 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-04-10 09:47:44 +00:00
|
|
|
}
|
2013-05-14 22:51:33 +00:00
|
|
|
|
2018-05-23 08:26:10 +00:00
|
|
|
TEST(CollectCpuProfileCallerLineNumbers) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
|
|
|
|
CompileRun(cpu_profiler_test_source);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
|
|
|
|
|
|
|
|
|
int32_t profiling_interval_ms = 200;
|
|
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), profiling_interval_ms)};
|
|
|
|
|
ProfilerHelper helper(env.local());
|
2019-05-22 00:06:41 +00:00
|
|
|
helper.Run(function, args, arraysize(args), 1000, 0,
|
|
|
|
|
v8::CpuProfilingMode::kCallerLineNumbers, 0);
|
2018-05-23 08:26:10 +00:00
|
|
|
v8::CpuProfile* profile =
|
2019-05-22 00:06:41 +00:00
|
|
|
helper.Run(function, args, arraysize(args), 1000, 0,
|
|
|
|
|
v8::CpuProfilingMode::kCallerLineNumbers, 0);
|
2018-05-23 08:26:10 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* start_node = GetChild(root, {"start", 27});
|
|
|
|
|
const v8::CpuProfileNode* foo_node = GetChild(start_node, {"foo", 30});
|
|
|
|
|
|
|
|
|
|
NameLinePair bar_branch[] = {{"bar", 23}, {"delay", 19}, {"loop", 18}};
|
|
|
|
|
CheckBranch(foo_node, bar_branch, arraysize(bar_branch));
|
|
|
|
|
NameLinePair baz_branch[] = {{"baz", 25}, {"delay", 20}, {"loop", 18}};
|
|
|
|
|
CheckBranch(foo_node, baz_branch, arraysize(baz_branch));
|
|
|
|
|
NameLinePair delay_at22_branch[] = {{"delay", 22}, {"loop", 18}};
|
|
|
|
|
CheckBranch(foo_node, delay_at22_branch, arraysize(delay_at22_branch));
|
|
|
|
|
NameLinePair delay_at24_branch[] = {{"delay", 24}, {"loop", 18}};
|
|
|
|
|
CheckBranch(foo_node, delay_at24_branch, arraysize(delay_at24_branch));
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2014-05-22 05:36:27 +00:00
|
|
|
static const char* hot_deopt_no_frame_entry_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function foo(a, b) {\n"
|
|
|
|
|
" return a + b;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start(timeout) {\n"
|
|
|
|
|
" var start = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" for (var i = 1; i < 1000; ++i) foo(1, i);\n"
|
|
|
|
|
" var duration = Date.now() - start;\n"
|
|
|
|
|
" } while (duration < timeout);\n"
|
|
|
|
|
" return duration;\n"
|
|
|
|
|
"}\n";
|
2014-05-22 05:36:27 +00:00
|
|
|
|
|
|
|
|
// Check that the profile tree for the script above will look like the
|
|
|
|
|
// following:
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 1062 0 (root) [-1]
|
|
|
|
|
// 1054 0 start [-1]
|
|
|
|
|
// 1054 1 foo [-1]
|
|
|
|
|
// 2 2 (program) [-1]
|
|
|
|
|
// 6 6 (garbage collector) [-1]
|
|
|
|
|
//
|
2016-02-12 17:30:01 +00:00
|
|
|
// The test checks no FP ranges are present in a deoptimized function.
|
2014-05-22 05:36:27 +00:00
|
|
|
// If 'foo' has no ranges the samples falling into the prologue will miss the
|
|
|
|
|
// 'start' function on the stack, so 'foo' will be attached to the (root).
|
|
|
|
|
TEST(HotDeoptNoFrameEntry) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-05-22 05:36:27 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(hot_deopt_no_frame_entry_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2014-05-22 05:36:27 +00:00
|
|
|
|
|
|
|
|
int32_t profiling_interval_ms = 200;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), profiling_interval_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 1000);
|
2015-12-08 18:44:23 +00:00
|
|
|
function->Call(env.local(), env->Global(), arraysize(args), args)
|
|
|
|
|
.ToLocalChecked();
|
2014-05-22 05:36:27 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "foo");
|
2014-05-22 05:36:27 +00:00
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2014-04-25 18:53:06 +00:00
|
|
|
TEST(CollectCpuProfileSamples) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-04-25 18:53:06 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(cpu_profiler_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2014-04-25 18:53:06 +00:00
|
|
|
|
|
|
|
|
int32_t profiling_interval_ms = 200;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), profiling_interval_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2014-04-25 18:53:06 +00:00
|
|
|
v8::CpuProfile* profile =
|
2019-05-22 00:06:41 +00:00
|
|
|
helper.Run(function, args, arraysize(args), 1000, 0);
|
2014-04-25 18:53:06 +00:00
|
|
|
|
|
|
|
|
CHECK_LE(200, profile->GetSamplesCount());
|
|
|
|
|
uint64_t end_time = profile->GetEndTime();
|
|
|
|
|
uint64_t current_time = profile->GetStartTime();
|
|
|
|
|
CHECK_LE(current_time, end_time);
|
|
|
|
|
for (int i = 0; i < profile->GetSamplesCount(); i++) {
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile->GetSample(i));
|
2014-04-25 18:53:06 +00:00
|
|
|
uint64_t timestamp = profile->GetSampleTimestamp(i);
|
|
|
|
|
CHECK_LE(current_time, timestamp);
|
|
|
|
|
CHECK_LE(timestamp, end_time);
|
|
|
|
|
current_time = timestamp;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
static const char* cpu_profiler_test_source2 =
|
|
|
|
|
"%NeverOptimizeFunction(loop);\n"
|
|
|
|
|
"%NeverOptimizeFunction(delay);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function loop() {}\n"
|
|
|
|
|
"function delay() { loop(); }\n"
|
|
|
|
|
"function start(duration) {\n"
|
|
|
|
|
" var start = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" for (var i = 0; i < 10000; ++i) delay();\n"
|
|
|
|
|
" } while (Date.now() - start < duration);\n"
|
|
|
|
|
"}";
|
2013-05-14 22:51:33 +00:00
|
|
|
|
2013-10-10 13:03:41 +00:00
|
|
|
// Check that the profile tree doesn't contain unexpected traces:
|
2013-05-14 22:51:33 +00:00
|
|
|
// - 'loop' can be called only by 'delay'
|
|
|
|
|
// - 'delay' may be called only by 'start'
|
|
|
|
|
// The profile will look like the following:
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 135 0 (root) [-1] #1
|
|
|
|
|
// 121 72 start [-1] #3
|
|
|
|
|
// 49 33 delay [-1] #4
|
|
|
|
|
// 16 16 loop [-1] #5
|
|
|
|
|
// 14 14 (program) [-1] #2
|
|
|
|
|
TEST(SampleWhenFrameIsNotSetup) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2013-05-14 22:51:33 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(cpu_profiler_test_source2);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-05-14 22:51:33 +00:00
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
int32_t duration_ms = 100;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
2016-02-08 18:12:04 +00:00
|
|
|
v8::Integer::New(env->GetIsolate(), duration_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 1000);
|
2013-05-14 22:51:33 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
const v8::CpuProfileNode* delay_node =
|
|
|
|
|
GetChild(env.local(), start_node, "delay");
|
|
|
|
|
GetChild(env.local(), delay_node, "loop");
|
2013-05-14 22:51:33 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-05-14 22:51:33 +00:00
|
|
|
}
|
2013-06-04 10:57:32 +00:00
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
static const char* native_accessor_test_source =
|
|
|
|
|
"function start(count) {\n"
|
|
|
|
|
" for (var i = 0; i < count; i++) {\n"
|
|
|
|
|
" var o = instance.foo;\n"
|
|
|
|
|
" instance.foo = o + 1;\n"
|
|
|
|
|
" }\n"
|
|
|
|
|
"}\n";
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2013-06-11 15:00:41 +00:00
|
|
|
class TestApiCallbacks {
|
2013-06-04 10:57:32 +00:00
|
|
|
public:
|
2013-06-11 15:00:41 +00:00
|
|
|
explicit TestApiCallbacks(int min_duration_ms)
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
: min_duration_ms_(min_duration_ms), is_warming_up_(false) {}
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2013-07-17 12:16:16 +00:00
|
|
|
static void Getter(v8::Local<v8::String> name,
|
|
|
|
|
const v8::PropertyCallbackInfo<v8::Value>& info) {
|
2016-02-08 18:12:04 +00:00
|
|
|
TestApiCallbacks* data = FromInfo(info);
|
2013-06-11 08:32:48 +00:00
|
|
|
data->Wait();
|
2013-06-04 10:57:32 +00:00
|
|
|
}
|
|
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
static void Setter(v8::Local<v8::String> name, v8::Local<v8::Value> value,
|
2013-07-17 12:16:16 +00:00
|
|
|
const v8::PropertyCallbackInfo<void>& info) {
|
2016-02-08 18:12:04 +00:00
|
|
|
TestApiCallbacks* data = FromInfo(info);
|
2013-06-11 15:00:41 +00:00
|
|
|
data->Wait();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void Callback(const v8::FunctionCallbackInfo<v8::Value>& info) {
|
2016-02-08 18:12:04 +00:00
|
|
|
TestApiCallbacks* data = FromInfo(info);
|
2013-06-11 08:32:48 +00:00
|
|
|
data->Wait();
|
2013-06-05 06:15:41 +00:00
|
|
|
}
|
|
|
|
|
|
2013-06-11 08:32:48 +00:00
|
|
|
void set_warming_up(bool value) { is_warming_up_ = value; }
|
2013-06-04 10:57:32 +00:00
|
|
|
|
|
|
|
|
private:
|
2013-06-11 08:32:48 +00:00
|
|
|
void Wait() {
|
|
|
|
|
if (is_warming_up_) return;
|
2017-08-25 07:12:51 +00:00
|
|
|
v8::Platform* platform = v8::internal::V8::GetCurrentPlatform();
|
|
|
|
|
double start = platform->CurrentClockTimeMillis();
|
2013-06-05 06:15:41 +00:00
|
|
|
double duration = 0;
|
|
|
|
|
while (duration < min_duration_ms_) {
|
2015-05-04 22:53:22 +00:00
|
|
|
v8::base::OS::Sleep(v8::base::TimeDelta::FromMilliseconds(1));
|
2017-08-25 07:12:51 +00:00
|
|
|
duration = platform->CurrentClockTimeMillis() - start;
|
2013-06-04 10:57:32 +00:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
template <typename T>
|
|
|
|
|
static TestApiCallbacks* FromInfo(const T& info) {
|
2013-06-04 10:57:32 +00:00
|
|
|
void* data = v8::External::Cast(*info.Data())->Value();
|
2013-06-11 15:00:41 +00:00
|
|
|
return reinterpret_cast<TestApiCallbacks*>(data);
|
2013-06-04 10:57:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
int min_duration_ms_;
|
2013-06-11 08:32:48 +00:00
|
|
|
bool is_warming_up_;
|
2013-06-04 10:57:32 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Test that native accessors are properly reported in the CPU profile.
|
|
|
|
|
// This test checks the case when the long-running accessors are called
|
|
|
|
|
// only once and the optimizer doesn't have chance to change the invocation
|
|
|
|
|
// code.
|
2013-06-11 08:32:48 +00:00
|
|
|
TEST(NativeAccessorUninitializedIC) {
|
2013-06-04 10:57:32 +00:00
|
|
|
LocalContext env;
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(isolate);
|
2013-06-04 10:57:32 +00:00
|
|
|
v8::Local<v8::ObjectTemplate> instance_template =
|
|
|
|
|
func_template->InstanceTemplate();
|
|
|
|
|
|
2013-06-11 15:00:41 +00:00
|
|
|
TestApiCallbacks accessors(100);
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::Local<v8::External> data = v8::External::New(isolate, &accessors);
|
2015-02-06 16:50:56 +00:00
|
|
|
instance_template->SetAccessor(v8_str("foo"), &TestApiCallbacks::Getter,
|
|
|
|
|
&TestApiCallbacks::Setter, data);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
v8::Local<v8::Object> instance =
|
|
|
|
|
func->NewInstance(env.local()).ToLocalChecked();
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("instance"), instance).FromJust();
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(native_accessor_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2013-06-04 10:57:32 +00:00
|
|
|
int32_t repeat_count = 1;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(isolate, repeat_count)};
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 0, 100);
|
2013-06-04 10:57:32 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "get foo");
|
|
|
|
|
GetChild(env.local(), start_node, "set foo");
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-06-04 10:57:32 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Test that native accessors are properly reported in the CPU profile.
|
|
|
|
|
// This test makes sure that the accessors are called enough times to become
|
|
|
|
|
// hot and to trigger optimizations.
|
2013-06-11 08:32:48 +00:00
|
|
|
TEST(NativeAccessorMonomorphicIC) {
|
2013-06-04 10:57:32 +00:00
|
|
|
LocalContext env;
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(isolate);
|
2013-06-04 10:57:32 +00:00
|
|
|
v8::Local<v8::ObjectTemplate> instance_template =
|
|
|
|
|
func_template->InstanceTemplate();
|
|
|
|
|
|
2013-06-11 15:00:41 +00:00
|
|
|
TestApiCallbacks accessors(1);
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
v8::Local<v8::External> data = v8::External::New(isolate, &accessors);
|
2015-02-06 16:50:56 +00:00
|
|
|
instance_template->SetAccessor(v8_str("foo"), &TestApiCallbacks::Getter,
|
|
|
|
|
&TestApiCallbacks::Setter, data);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
v8::Local<v8::Object> instance =
|
|
|
|
|
func->NewInstance(env.local()).ToLocalChecked();
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("instance"), instance).FromJust();
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(native_accessor_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2013-06-11 08:32:48 +00:00
|
|
|
{
|
|
|
|
|
// Make sure accessors ICs are in monomorphic state before starting
|
|
|
|
|
// profiling.
|
|
|
|
|
accessors.set_warming_up(true);
|
|
|
|
|
int32_t warm_up_iterations = 3;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(isolate, warm_up_iterations)};
|
|
|
|
|
function->Call(env.local(), env->Global(), arraysize(args), args)
|
|
|
|
|
.ToLocalChecked();
|
2013-06-11 08:32:48 +00:00
|
|
|
accessors.set_warming_up(false);
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-04 10:57:32 +00:00
|
|
|
int32_t repeat_count = 100;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(isolate, repeat_count)};
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 0, 100);
|
2013-06-04 10:57:32 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "get foo");
|
|
|
|
|
GetChild(env.local(), start_node, "set foo");
|
2013-06-04 10:57:32 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-06-04 10:57:32 +00:00
|
|
|
}
|
2013-06-11 15:00:41 +00:00
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
static const char* native_method_test_source =
|
|
|
|
|
"function start(count) {\n"
|
|
|
|
|
" for (var i = 0; i < count; i++) {\n"
|
|
|
|
|
" instance.fooMethod();\n"
|
|
|
|
|
" }\n"
|
|
|
|
|
"}\n";
|
2013-06-11 15:00:41 +00:00
|
|
|
|
|
|
|
|
TEST(NativeMethodUninitializedIC) {
|
|
|
|
|
LocalContext env;
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
|
|
|
|
TestApiCallbacks callbacks(100);
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::Local<v8::External> data = v8::External::New(isolate, &callbacks);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(isolate);
|
2016-07-08 15:00:23 +00:00
|
|
|
func_template->SetClassName(v8_str("Test_InstanceConstructor"));
|
2013-06-11 15:00:41 +00:00
|
|
|
v8::Local<v8::ObjectTemplate> proto_template =
|
|
|
|
|
func_template->PrototypeTemplate();
|
2013-11-28 08:21:26 +00:00
|
|
|
v8::Local<v8::Signature> signature =
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Signature::New(isolate, func_template);
|
2015-02-06 16:50:56 +00:00
|
|
|
proto_template->Set(
|
|
|
|
|
v8_str("fooMethod"),
|
|
|
|
|
v8::FunctionTemplate::New(isolate, &TestApiCallbacks::Callback, data,
|
|
|
|
|
signature, 0));
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
v8::Local<v8::Object> instance =
|
|
|
|
|
func->NewInstance(env.local()).ToLocalChecked();
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("instance"), instance).FromJust();
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(native_method_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2013-06-11 15:00:41 +00:00
|
|
|
int32_t repeat_count = 1;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(isolate, repeat_count)};
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 0, 100);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "fooMethod");
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-06-11 15:00:41 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(NativeMethodMonomorphicIC) {
|
|
|
|
|
LocalContext env;
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Isolate* isolate = env->GetIsolate();
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
|
|
|
|
TestApiCallbacks callbacks(1);
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
v8::Local<v8::External> data = v8::External::New(isolate, &callbacks);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(isolate);
|
2015-02-06 16:50:56 +00:00
|
|
|
func_template->SetClassName(v8_str("Test_InstanceCostructor"));
|
2013-06-11 15:00:41 +00:00
|
|
|
v8::Local<v8::ObjectTemplate> proto_template =
|
|
|
|
|
func_template->PrototypeTemplate();
|
2013-11-28 08:21:26 +00:00
|
|
|
v8::Local<v8::Signature> signature =
|
2013-12-18 10:31:42 +00:00
|
|
|
v8::Signature::New(isolate, func_template);
|
2015-02-06 16:50:56 +00:00
|
|
|
proto_template->Set(
|
|
|
|
|
v8_str("fooMethod"),
|
|
|
|
|
v8::FunctionTemplate::New(isolate, &TestApiCallbacks::Callback, data,
|
|
|
|
|
signature, 0));
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
v8::Local<v8::Object> instance =
|
|
|
|
|
func->NewInstance(env.local()).ToLocalChecked();
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("instance"), instance).FromJust();
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(native_method_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-06-11 15:00:41 +00:00
|
|
|
{
|
|
|
|
|
// Make sure method ICs are in monomorphic state before starting
|
|
|
|
|
// profiling.
|
|
|
|
|
callbacks.set_warming_up(true);
|
|
|
|
|
int32_t warm_up_iterations = 3;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(isolate, warm_up_iterations)};
|
|
|
|
|
function->Call(env.local(), env->Global(), arraysize(args), args)
|
|
|
|
|
.ToLocalChecked();
|
2013-06-11 15:00:41 +00:00
|
|
|
callbacks.set_warming_up(false);
|
|
|
|
|
}
|
|
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2013-06-11 15:00:41 +00:00
|
|
|
int32_t repeat_count = 100;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(isolate, repeat_count)};
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 0, 200);
|
2013-06-11 15:00:41 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2015-12-08 18:44:23 +00:00
|
|
|
GetChild(env.local(), root, "start");
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "fooMethod");
|
2013-06-11 15:00:41 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-06-11 15:00:41 +00:00
|
|
|
}
|
2013-06-27 09:28:11 +00:00
|
|
|
|
2014-07-11 09:06:12 +00:00
|
|
|
static const char* bound_function_test_source =
|
|
|
|
|
"function foo() {\n"
|
|
|
|
|
" startProfiling('my_profile');\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
|
|
|
|
" var callback = foo.bind(this);\n"
|
|
|
|
|
" callback();\n"
|
|
|
|
|
"}";
|
2013-06-27 09:28:11 +00:00
|
|
|
|
|
|
|
|
TEST(BoundFunctionCall) {
|
2014-07-11 09:06:12 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-07-11 09:06:12 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2013-06-27 09:28:11 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(bound_function_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
2013-06-27 09:28:11 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0);
|
2013-06-27 09:28:11 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
GetChild(env, start_node, "foo");
|
2013-06-27 09:28:11 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-06-27 09:28:11 +00:00
|
|
|
}
|
2013-07-02 07:51:09 +00:00
|
|
|
|
2014-11-06 09:16:34 +00:00
|
|
|
// This tests checks distribution of the samples through the source lines.
|
2016-03-02 02:10:03 +00:00
|
|
|
static void TickLines(bool optimize) {
|
2018-10-22 11:45:45 +00:00
|
|
|
#ifndef V8_LITE_MODE
|
|
|
|
|
FLAG_opt = optimize;
|
|
|
|
|
#endif // V8_LITE_MODE
|
2014-11-06 09:16:34 +00:00
|
|
|
CcTest::InitializeVM();
|
|
|
|
|
LocalContext env;
|
2016-03-02 02:10:03 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-11-06 09:16:34 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::Factory* factory = isolate->factory();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
i::EmbeddedVector<char, 512> script;
|
2019-04-30 11:04:41 +00:00
|
|
|
i::EmbeddedVector<char, 64> prepare_opt;
|
2016-09-27 16:27:31 +00:00
|
|
|
i::EmbeddedVector<char, 64> optimize_call;
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
const char* func_name = "func";
|
2016-09-27 16:27:31 +00:00
|
|
|
if (optimize) {
|
2019-04-30 11:04:41 +00:00
|
|
|
i::SNPrintF(prepare_opt, "%%PrepareFunctionForOptimization(%s);\n",
|
|
|
|
|
func_name);
|
2016-09-27 16:27:31 +00:00
|
|
|
i::SNPrintF(optimize_call, "%%OptimizeFunctionOnNextCall(%s);\n",
|
|
|
|
|
func_name);
|
|
|
|
|
} else {
|
2019-04-30 11:04:41 +00:00
|
|
|
prepare_opt[0] = '\0';
|
2016-09-27 19:28:38 +00:00
|
|
|
optimize_call[0] = '\0';
|
2016-09-27 16:27:31 +00:00
|
|
|
}
|
2014-11-06 09:16:34 +00:00
|
|
|
i::SNPrintF(script,
|
|
|
|
|
"function %s() {\n"
|
|
|
|
|
" var n = 0;\n"
|
|
|
|
|
" var m = 100*100;\n"
|
|
|
|
|
" while (m > 1) {\n"
|
|
|
|
|
" m--;\n"
|
|
|
|
|
" n += m * m * m;\n"
|
|
|
|
|
" }\n"
|
|
|
|
|
"}\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%s"
|
2016-09-27 16:27:31 +00:00
|
|
|
"%s();\n"
|
|
|
|
|
"%s"
|
2014-11-06 09:16:34 +00:00
|
|
|
"%s();\n",
|
2019-04-30 11:04:41 +00:00
|
|
|
func_name, prepare_opt.begin(), func_name, optimize_call.begin(),
|
|
|
|
|
func_name);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
2019-04-29 11:06:49 +00:00
|
|
|
CompileRun(script.begin());
|
2014-11-06 09:16:34 +00:00
|
|
|
|
2015-10-23 12:26:49 +00:00
|
|
|
i::Handle<i::JSFunction> func = i::Handle<i::JSFunction>::cast(
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Utils::OpenHandle(*GetFunction(env.local(), func_name)));
|
2018-11-28 19:57:30 +00:00
|
|
|
CHECK(!func->shared().is_null());
|
2019-05-23 07:47:44 +00:00
|
|
|
CHECK(!func->shared().abstract_code().is_null());
|
2020-08-11 09:24:47 +00:00
|
|
|
CHECK(!optimize || func->HasAttachedOptimizedCode() ||
|
2017-04-28 15:36:46 +00:00
|
|
|
!CcTest::i_isolate()->use_optimizer());
|
2019-12-20 10:54:21 +00:00
|
|
|
i::Handle<i::AbstractCode> code(func->abstract_code(), isolate);
|
|
|
|
|
CHECK(!code->is_null());
|
|
|
|
|
i::Address code_address = code->raw_instruction_start();
|
2018-11-25 03:47:59 +00:00
|
|
|
CHECK_NE(code_address, kNullAddress);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
2016-06-15 09:59:00 +00:00
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
2019-03-14 07:25:55 +00:00
|
|
|
ProfilerEventsProcessor* processor = new SamplingEventsProcessor(
|
2019-07-18 23:18:18 +00:00
|
|
|
CcTest::i_isolate(), generator, &code_observer,
|
2019-03-14 07:25:55 +00:00
|
|
|
v8::base::TimeDelta::FromMicroseconds(100), true);
|
2019-07-18 23:18:18 +00:00
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-09 19:20:21 +00:00
|
|
|
profiles->StartProfiling("");
|
2019-03-26 15:17:30 +00:00
|
|
|
// TODO(delphick): Stop using the CpuProfiler internals here: This forces
|
|
|
|
|
// LogCompiledFunctions so that source positions are collected everywhere.
|
|
|
|
|
// This would normally happen automatically with CpuProfiler::StartProfiling
|
|
|
|
|
// but doesn't because it's constructed with a generator and a processor.
|
|
|
|
|
isolate->logger()->LogCompiledFunctions();
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2018-10-17 12:09:34 +00:00
|
|
|
ProfilerListener profiler_listener(isolate, processor);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
// Enqueue code creation events.
|
|
|
|
|
i::Handle<i::String> str = factory->NewStringFromAsciiChecked(func_name);
|
|
|
|
|
int line = 1;
|
|
|
|
|
int column = 1;
|
2016-06-22 16:43:46 +00:00
|
|
|
profiler_listener.CodeCreateEvent(i::Logger::FUNCTION_TAG, code,
|
2019-12-20 10:54:21 +00:00
|
|
|
handle(func->shared(), isolate), str, line,
|
|
|
|
|
column);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
// Enqueue a tick event to enable code events processing.
|
2016-06-15 09:59:00 +00:00
|
|
|
EnqueueTickSampleEvent(processor, code_address);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
processor->StopSynchronously();
|
|
|
|
|
|
|
|
|
|
CpuProfile* profile = profiles->StopProfiling("");
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
// Check the state of profile generator.
|
2016-06-15 09:59:00 +00:00
|
|
|
CodeEntry* func_entry = generator->code_map()->FindEntry(code_address);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(func_entry);
|
2015-02-06 16:50:56 +00:00
|
|
|
CHECK_EQ(0, strcmp(func_name, func_entry->name()));
|
2018-04-11 13:09:15 +00:00
|
|
|
const i::SourcePositionTable* line_info = func_entry->line_info();
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(line_info);
|
2018-04-11 13:09:15 +00:00
|
|
|
CHECK_NE(v8::CpuProfileNode::kNoLineNumberInfo,
|
|
|
|
|
line_info->GetSourceLineNumber(100));
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
// Check the hit source lines using V8 Public APIs.
|
|
|
|
|
const i::ProfileTree* tree = profile->top_down();
|
|
|
|
|
ProfileNode* root = tree->root();
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(root);
|
2014-11-06 09:16:34 +00:00
|
|
|
ProfileNode* func_node = root->FindChild(func_entry);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(func_node);
|
2014-11-06 09:16:34 +00:00
|
|
|
|
|
|
|
|
// Add 10 faked ticks to source line #5.
|
|
|
|
|
int hit_line = 5;
|
|
|
|
|
int hit_count = 10;
|
|
|
|
|
for (int i = 0; i < hit_count; i++) func_node->IncrementLineTicks(hit_line);
|
|
|
|
|
|
|
|
|
|
unsigned int line_count = func_node->GetHitLineCount();
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK_EQ(2u, line_count); // Expect two hit source lines - #1 and #5.
|
2014-11-06 09:16:34 +00:00
|
|
|
ScopedVector<v8::CpuProfileNode::LineTick> entries(line_count);
|
|
|
|
|
CHECK(func_node->GetLineTicks(&entries[0], line_count));
|
|
|
|
|
int value = 0;
|
|
|
|
|
for (int i = 0; i < entries.length(); i++)
|
|
|
|
|
if (entries[i].line == hit_line) {
|
|
|
|
|
value = entries[i].hit_count;
|
|
|
|
|
break;
|
|
|
|
|
}
|
|
|
|
|
CHECK_EQ(hit_count, value);
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-02 02:10:03 +00:00
|
|
|
TEST(TickLinesBaseline) { TickLines(false); }
|
|
|
|
|
|
|
|
|
|
TEST(TickLinesOptimized) { TickLines(true); }
|
|
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
static const char* call_function_test_source =
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function bar(n) {\n"
|
|
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < n; i++) s += i * i * i;\n"
|
|
|
|
|
" return s;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start(duration) {\n"
|
|
|
|
|
" var start = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" for (var i = 0; i < 100; ++i)\n"
|
|
|
|
|
" bar.call(this, 1000);\n"
|
|
|
|
|
" } while (Date.now() - start < duration);\n"
|
|
|
|
|
"}";
|
2013-07-02 07:51:09 +00:00
|
|
|
|
|
|
|
|
// Test that if we sampled thread when it was inside FunctionCall buitin then
|
|
|
|
|
// its caller frame will be '(unresolved function)' as we have no reliable way
|
|
|
|
|
// to resolve it.
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 96 0 (root) [-1] #1
|
|
|
|
|
// 1 1 (garbage collector) [-1] #4
|
|
|
|
|
// 5 0 (unresolved function) [-1] #5
|
|
|
|
|
// 5 5 call [-1] #6
|
|
|
|
|
// 71 70 start [-1] #3
|
|
|
|
|
// 1 1 bar [-1] #7
|
|
|
|
|
// 19 19 (program) [-1] #2
|
|
|
|
|
TEST(FunctionCallSample) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2013-07-02 07:51:09 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
// Collect garbage that might have be generated while installing
|
|
|
|
|
// extensions.
|
2017-04-26 22:16:41 +00:00
|
|
|
CcTest::CollectAllGarbage();
|
2013-07-08 11:26:15 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(call_function_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-07-02 07:51:09 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2013-07-02 07:51:09 +00:00
|
|
|
int32_t duration_ms = 100;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), duration_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 1000);
|
2013-07-02 07:51:09 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "bar");
|
2013-07-02 07:51:09 +00:00
|
|
|
|
2016-06-22 16:43:46 +00:00
|
|
|
const v8::CpuProfileNode* unresolved_node =
|
|
|
|
|
FindChild(env.local(), root, i::CodeEntry::kUnresolvedFunctionName);
|
2016-02-08 18:12:04 +00:00
|
|
|
CHECK(!unresolved_node || GetChild(env.local(), unresolved_node, "call"));
|
2013-07-02 07:51:09 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-07-02 07:51:09 +00:00
|
|
|
}
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
static const char* function_apply_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(test);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function bar(n) {\n"
|
|
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < n; i++) s += i * i * i;\n"
|
|
|
|
|
" return s;\n"
|
2015-02-06 16:50:56 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function test() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" bar.apply(this, [1000]);\n"
|
2015-02-06 16:50:56 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function start(duration) {\n"
|
|
|
|
|
" var start = Date.now();\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" do {\n"
|
|
|
|
|
" for (var i = 0; i < 100; ++i) test();\n"
|
|
|
|
|
" } while (Date.now() - start < duration);\n"
|
2015-02-06 16:50:56 +00:00
|
|
|
"}";
|
2013-07-03 14:04:37 +00:00
|
|
|
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 94 0 (root) [-1] #0 1
|
|
|
|
|
// 2 2 (garbage collector) [-1] #0 7
|
|
|
|
|
// 82 49 start [-1] #16 3
|
|
|
|
|
// 1 0 (unresolved function) [-1] #0 8
|
|
|
|
|
// 1 1 apply [-1] #0 9
|
|
|
|
|
// 32 21 test [-1] #16 4
|
|
|
|
|
// 2 2 bar [-1] #16 6
|
|
|
|
|
// 10 10 (program) [-1] #0 2
|
|
|
|
|
TEST(FunctionApplySample) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2013-07-03 14:04:37 +00:00
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(function_apply_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2013-07-03 14:04:37 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2013-07-03 14:04:37 +00:00
|
|
|
int32_t duration_ms = 100;
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {
|
|
|
|
|
v8::Integer::New(env->GetIsolate(), duration_ms)};
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, args, arraysize(args), 1000);
|
2013-07-03 14:04:37 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
const v8::CpuProfileNode* test_node =
|
|
|
|
|
GetChild(env.local(), start_node, "test");
|
|
|
|
|
GetChild(env.local(), test_node, "bar");
|
2013-07-03 14:04:37 +00:00
|
|
|
|
2016-06-22 16:43:46 +00:00
|
|
|
const v8::CpuProfileNode* unresolved_node =
|
|
|
|
|
FindChild(env.local(), start_node, CodeEntry::kUnresolvedFunctionName);
|
2016-02-08 18:12:04 +00:00
|
|
|
CHECK(!unresolved_node || GetChild(env.local(), unresolved_node, "apply"));
|
2013-07-03 14:04:37 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-07-03 14:04:37 +00:00
|
|
|
}
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2014-06-24 16:00:51 +00:00
|
|
|
static const char* cpu_profiler_deep_stack_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"function foo(n) {\n"
|
|
|
|
|
" if (n)\n"
|
|
|
|
|
" foo(n - 1);\n"
|
|
|
|
|
" else\n"
|
|
|
|
|
" collectSample();\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
|
|
|
|
" startProfiling('my_profile');\n"
|
|
|
|
|
" foo(250);\n"
|
|
|
|
|
"}\n";
|
2014-06-24 16:00:51 +00:00
|
|
|
|
|
|
|
|
// Check a deep stack
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 0 (root) 0 #1
|
|
|
|
|
// 2 (program) 0 #2
|
|
|
|
|
// 0 start 21 #3 no reason
|
|
|
|
|
// 0 foo 21 #4 no reason
|
|
|
|
|
// 0 foo 21 #5 no reason
|
|
|
|
|
// ....
|
2016-02-08 18:12:04 +00:00
|
|
|
// 0 foo 21 #254 no reason
|
2014-06-24 16:00:51 +00:00
|
|
|
TEST(CpuProfileDeepStack) {
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-06-24 16:00:51 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
2014-06-24 16:00:51 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(cpu_profiler_deep_stack_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
2014-06-24 16:00:51 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> profile_name = v8_str("my_profile");
|
2017-10-13 16:33:03 +00:00
|
|
|
function->Call(env, env->Global(), 0, nullptr).ToLocalChecked();
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.profiler()->StopProfiling(profile_name);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2014-06-24 16:00:51 +00:00
|
|
|
// Dump collected profile to have a better diagnostic in case of failure.
|
|
|
|
|
reinterpret_cast<i::CpuProfile*>(profile)->Print();
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* node = GetChild(env, root, "start");
|
2016-02-08 18:12:04 +00:00
|
|
|
for (int i = 0; i <= 250; ++i) {
|
2015-12-08 18:44:23 +00:00
|
|
|
node = GetChild(env, node, "foo");
|
2014-06-24 16:00:51 +00:00
|
|
|
}
|
2016-02-08 18:12:04 +00:00
|
|
|
CHECK(!FindChild(env, node, "foo"));
|
2014-06-24 16:00:51 +00:00
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2013-10-10 13:03:41 +00:00
|
|
|
static const char* js_native_js_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function foo(n) {\n"
|
|
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < n; i++) s += i * i * i;\n"
|
|
|
|
|
" return s;\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function bar() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" foo(1000);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" CallJsFunction(bar);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}";
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
static void CallJsFunction(const v8::FunctionCallbackInfo<v8::Value>& info) {
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = info[0].As<v8::Function>();
|
|
|
|
|
v8::Local<v8::Value> argv[] = {info[1]};
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
function
|
|
|
|
|
->Call(info.GetIsolate()->GetCurrentContext(), info.This(),
|
|
|
|
|
arraysize(argv), argv)
|
2015-12-08 18:44:23 +00:00
|
|
|
.ToLocalChecked();
|
2013-07-23 15:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 58 0 (root) #0 1
|
|
|
|
|
// 2 2 (program) #0 2
|
|
|
|
|
// 56 1 start #16 3
|
|
|
|
|
// 55 0 CallJsFunction #0 4
|
|
|
|
|
// 55 1 bar #16 5
|
|
|
|
|
// 54 54 foo #16 6
|
|
|
|
|
TEST(JsNativeJsSample) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallJsFunction);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env).ToLocalChecked();
|
2015-02-06 16:50:56 +00:00
|
|
|
func->SetName(v8_str("CallJsFunction"));
|
2015-12-08 18:44:23 +00:00
|
|
|
env->Global()->Set(env, v8_str("CallJsFunction"), func).FromJust();
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(js_native_js_test_source);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 1000);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
const v8::CpuProfileNode* native_node =
|
|
|
|
|
GetChild(env, start_node, "CallJsFunction");
|
|
|
|
|
const v8::CpuProfileNode* bar_node = GetChild(env, native_node, "bar");
|
|
|
|
|
GetChild(env, bar_node, "foo");
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-07-23 15:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char* js_native_js_runtime_js_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function foo(n) {\n"
|
|
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < n; i++) s += i * i * i;\n"
|
|
|
|
|
" return s;\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}\n"
|
|
|
|
|
"var bound = foo.bind(this);\n"
|
|
|
|
|
"function bar() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" bound(1000);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" CallJsFunction(bar);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}";
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 57 0 (root) #0 1
|
|
|
|
|
// 55 1 start #16 3
|
|
|
|
|
// 54 0 CallJsFunction #0 4
|
|
|
|
|
// 54 3 bar #16 5
|
|
|
|
|
// 51 51 foo #16 6
|
|
|
|
|
// 2 2 (program) #0 2
|
|
|
|
|
TEST(JsNativeJsRuntimeJsSample) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallJsFunction);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env).ToLocalChecked();
|
2015-02-06 16:50:56 +00:00
|
|
|
func->SetName(v8_str("CallJsFunction"));
|
2015-12-08 18:44:23 +00:00
|
|
|
env->Global()->Set(env, v8_str("CallJsFunction"), func).FromJust();
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(js_native_js_runtime_js_test_source);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 1000);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
const v8::CpuProfileNode* native_node =
|
|
|
|
|
GetChild(env, start_node, "CallJsFunction");
|
|
|
|
|
const v8::CpuProfileNode* bar_node = GetChild(env, native_node, "bar");
|
|
|
|
|
GetChild(env, bar_node, "foo");
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-07-23 15:01:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static void CallJsFunction2(const v8::FunctionCallbackInfo<v8::Value>& info) {
|
2014-07-01 10:10:12 +00:00
|
|
|
v8::base::OS::Print("In CallJsFunction2\n");
|
2013-07-23 15:01:38 +00:00
|
|
|
CallJsFunction(info);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char* js_native1_js_native2_js_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"function foo() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < 1000; i++) s += i * i * i;\n"
|
|
|
|
|
" return s;\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function bar() {\n"
|
|
|
|
|
" CallJsFunction2(foo);\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" CallJsFunction1(bar);\n"
|
2014-07-11 09:06:12 +00:00
|
|
|
"}";
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 57 0 (root) #0 1
|
|
|
|
|
// 55 1 start #16 3
|
|
|
|
|
// 54 0 CallJsFunction1 #0 4
|
|
|
|
|
// 54 0 bar #16 5
|
|
|
|
|
// 54 0 CallJsFunction2 #0 6
|
|
|
|
|
// 54 54 foo #16 7
|
|
|
|
|
// 2 2 (program) #0 2
|
|
|
|
|
TEST(JsNative1JsNative2JsSample) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func1 =
|
2016-02-08 18:12:04 +00:00
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallJsFunction)
|
|
|
|
|
->GetFunction(env)
|
|
|
|
|
.ToLocalChecked();
|
2015-02-06 16:50:56 +00:00
|
|
|
func1->SetName(v8_str("CallJsFunction1"));
|
2015-12-08 18:44:23 +00:00
|
|
|
env->Global()->Set(env, v8_str("CallJsFunction1"), func1).FromJust();
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Function> func2 =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallJsFunction2)
|
|
|
|
|
->GetFunction(env)
|
|
|
|
|
.ToLocalChecked();
|
2015-02-06 16:50:56 +00:00
|
|
|
func2->SetName(v8_str("CallJsFunction2"));
|
2015-12-08 18:44:23 +00:00
|
|
|
env->Global()->Set(env, v8_str("CallJsFunction2"), func2).FromJust();
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
CompileRun(js_native1_js_native2_js_test_source);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 1000);
|
2013-07-23 15:01:38 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
const v8::CpuProfileNode* native_node1 =
|
|
|
|
|
GetChild(env, start_node, "CallJsFunction1");
|
|
|
|
|
const v8::CpuProfileNode* bar_node = GetChild(env, native_node1, "bar");
|
|
|
|
|
const v8::CpuProfileNode* native_node2 =
|
|
|
|
|
GetChild(env, bar_node, "CallJsFunction2");
|
|
|
|
|
GetChild(env, native_node2, "foo");
|
2013-07-23 15:01:38 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2013-07-23 15:01:38 +00:00
|
|
|
}
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2016-01-26 20:47:23 +00:00
|
|
|
static const char* js_force_collect_sample_source =
|
|
|
|
|
"function start() {\n"
|
|
|
|
|
" CallCollectSample();\n"
|
|
|
|
|
"}";
|
|
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
static void CallCollectSample(const v8::FunctionCallbackInfo<v8::Value>& info) {
|
2017-11-14 20:23:15 +00:00
|
|
|
v8::CpuProfiler::CollectSample(info.GetIsolate());
|
2016-07-08 15:00:23 +00:00
|
|
|
}
|
|
|
|
|
|
2016-01-26 20:47:23 +00:00
|
|
|
TEST(CollectSampleAPI) {
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2016-01-26 20:47:23 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
env->Global()->Set(env, v8_str("CallCollectSample"), func).FromJust();
|
|
|
|
|
|
|
|
|
|
CompileRun(js_force_collect_sample_source);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
2016-01-26 20:47:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 0);
|
2016-01-26 20:47:23 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
CHECK_LE(1, start_node->GetChildrenCount());
|
|
|
|
|
GetChild(env, start_node, "CallCollectSample");
|
2016-01-26 20:47:23 +00:00
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2016-02-04 20:00:28 +00:00
|
|
|
static const char* js_native_js_runtime_multiple_test_source =
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
2016-02-04 20:00:28 +00:00
|
|
|
"function foo() {\n"
|
|
|
|
|
" return Math.sin(Math.random());\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"var bound = foo.bind(this);\n"
|
|
|
|
|
"function bar() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" return bound();\n"
|
2016-02-04 20:00:28 +00:00
|
|
|
"}\n"
|
|
|
|
|
"function start() {\n"
|
2016-02-08 18:12:04 +00:00
|
|
|
" startProfiling('my_profile');\n"
|
|
|
|
|
" var startTime = Date.now();\n"
|
|
|
|
|
" do {\n"
|
|
|
|
|
" CallJsFunction(bar);\n"
|
|
|
|
|
" } while (Date.now() - startTime < 200);\n"
|
2016-02-04 20:00:28 +00:00
|
|
|
"}";
|
|
|
|
|
|
|
|
|
|
// The test check multiple entrances/exits between JS and native code.
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// (root) #0 1
|
|
|
|
|
// start #16 3
|
|
|
|
|
// CallJsFunction #0 4
|
|
|
|
|
// bar #16 5
|
|
|
|
|
// foo #16 6
|
|
|
|
|
// (program) #0 2
|
|
|
|
|
TEST(JsNativeJsRuntimeJsSampleMultiple) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2016-02-04 20:00:28 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2016-02-04 20:00:28 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallJsFunction);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallJsFunction"));
|
|
|
|
|
env->Global()->Set(env, v8_str("CallJsFunction"), func).FromJust();
|
|
|
|
|
|
|
|
|
|
CompileRun(js_native_js_runtime_multiple_test_source);
|
|
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 500, 500);
|
2016-02-04 20:00:28 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
const v8::CpuProfileNode* native_node =
|
|
|
|
|
GetChild(env, start_node, "CallJsFunction");
|
|
|
|
|
const v8::CpuProfileNode* bar_node = GetChild(env, native_node, "bar");
|
|
|
|
|
GetChild(env, bar_node, "foo");
|
2016-02-04 20:00:28 +00:00
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2016-03-01 05:59:32 +00:00
|
|
|
static const char* inlining_test_source =
|
|
|
|
|
"var finish = false;\n"
|
|
|
|
|
"function action(n) {\n"
|
|
|
|
|
" var s = 0;\n"
|
|
|
|
|
" for (var i = 0; i < n; ++i) s += i*i*i;\n"
|
|
|
|
|
" if (finish)\n"
|
|
|
|
|
" startProfiling('my_profile');\n"
|
|
|
|
|
" return s;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"function level3() { return action(100); }\n"
|
|
|
|
|
"function level2() { return level3() * 2; }\n"
|
|
|
|
|
"function level1() { return level2(); }\n"
|
|
|
|
|
"function start() {\n"
|
|
|
|
|
" var n = 100;\n"
|
|
|
|
|
" while (--n)\n"
|
|
|
|
|
" level1();\n"
|
|
|
|
|
" finish = true;\n"
|
|
|
|
|
" level1();\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"}"
|
|
|
|
|
"%PrepareFunctionForOptimization(level1);\n"
|
|
|
|
|
"%PrepareFunctionForOptimization(level2);\n"
|
|
|
|
|
"%PrepareFunctionForOptimization(level3);\n"
|
|
|
|
|
"%NeverOptimizeFunction(action);\n"
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"level1();\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(level1);\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(level2);\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(level3);\n";
|
2016-03-01 05:59:32 +00:00
|
|
|
|
|
|
|
|
// The test check multiple entrances/exits between JS and native code.
|
|
|
|
|
//
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// (root) #0 1
|
|
|
|
|
// start #16 3
|
|
|
|
|
// level1 #0 4
|
|
|
|
|
// level2 #16 5
|
|
|
|
|
// level3 #16 6
|
|
|
|
|
// action #16 7
|
|
|
|
|
// (program) #0 2
|
|
|
|
|
TEST(Inlining) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2016-03-01 05:59:32 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
2016-03-01 05:59:32 +00:00
|
|
|
|
|
|
|
|
CompileRun(inlining_test_source);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::String> profile_name = v8_str("my_profile");
|
2017-10-13 16:33:03 +00:00
|
|
|
function->Call(env, env->Global(), 0, nullptr).ToLocalChecked();
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfile* profile = helper.profiler()->StopProfiling(profile_name);
|
2016-03-01 05:59:32 +00:00
|
|
|
CHECK(profile);
|
|
|
|
|
// Dump collected profile to have a better diagnostic in case of failure.
|
|
|
|
|
reinterpret_cast<i::CpuProfile*>(profile)->Print();
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env, root, "start");
|
|
|
|
|
const v8::CpuProfileNode* level1_node = GetChild(env, start_node, "level1");
|
|
|
|
|
const v8::CpuProfileNode* level2_node = GetChild(env, level1_node, "level2");
|
|
|
|
|
const v8::CpuProfileNode* level3_node = GetChild(env, level2_node, "level3");
|
|
|
|
|
GetChild(env, level3_node, "action");
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2019-01-02 12:19:06 +00:00
|
|
|
static const char* inlining_test_source2 = R"(
|
|
|
|
|
function action(n) {
|
|
|
|
|
var s = 0;
|
|
|
|
|
for (var i = 0; i < n; ++i) s += i*i*i;
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
function level4() {
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
action(100);
|
|
|
|
|
return action(100);
|
2019-01-02 12:19:06 +00:00
|
|
|
}
|
|
|
|
|
function level3() {
|
|
|
|
|
const a = level4();
|
|
|
|
|
const b = level4();
|
|
|
|
|
return a + b * 1.1;
|
|
|
|
|
}
|
|
|
|
|
function level2() {
|
|
|
|
|
return level3() * 2;
|
|
|
|
|
}
|
|
|
|
|
function level1() {
|
|
|
|
|
action(1);
|
|
|
|
|
action(200);
|
|
|
|
|
action(1);
|
|
|
|
|
return level2();
|
|
|
|
|
}
|
|
|
|
|
function start(n) {
|
|
|
|
|
while (--n)
|
|
|
|
|
level1();
|
|
|
|
|
};
|
2019-04-30 11:04:41 +00:00
|
|
|
%NeverOptimizeFunction(action);
|
|
|
|
|
%NeverOptimizeFunction(start);
|
|
|
|
|
%PrepareFunctionForOptimization(level1);
|
|
|
|
|
%PrepareFunctionForOptimization(level2);
|
|
|
|
|
%PrepareFunctionForOptimization(level3);
|
|
|
|
|
%PrepareFunctionForOptimization(level4);
|
|
|
|
|
level1();
|
|
|
|
|
level1();
|
|
|
|
|
%OptimizeFunctionOnNextCall(level1);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level2);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level3);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level4);
|
|
|
|
|
level1();
|
2019-01-02 12:19:06 +00:00
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
// [Top down]:
|
|
|
|
|
// 0 (root):0 0 #1
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
// 13 start:34 6 #3
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 19 level1:36 6 #4
|
|
|
|
|
// 16 action:29 6 #14
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 2748 action:30 6 #10
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 18 action:31 6 #15
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 0 level2:32 6 #5
|
|
|
|
|
// 0 level3:26 6 #6
|
|
|
|
|
// 12 level4:22 6 #11
|
|
|
|
|
// 1315 action:17 6 #13
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 1324 action:18 6 #12
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 16 level4:21 6 #7
|
|
|
|
|
// 1268 action:17 6 #9
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
|
|
|
|
// 1322 action:18 6 #8
|
|
|
|
|
// bailed out due to 'Optimization is always disabled'
|
2019-01-02 12:19:06 +00:00
|
|
|
// 2 (program):0 0 #2
|
|
|
|
|
TEST(Inlining2) {
|
2019-01-08 14:32:58 +00:00
|
|
|
FLAG_allow_natives_syntax = true;
|
2019-05-20 10:33:40 +00:00
|
|
|
v8::Isolate* isolate = CcTest::isolate();
|
2020-01-02 13:27:34 +00:00
|
|
|
LocalContext env;
|
2019-05-20 10:33:40 +00:00
|
|
|
v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2020-01-02 13:27:34 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2019-01-02 12:19:06 +00:00
|
|
|
|
|
|
|
|
CompileRun(inlining_test_source2);
|
2020-01-02 13:27:34 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2019-01-02 12:19:06 +00:00
|
|
|
|
2020-01-02 13:27:34 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(env->GetIsolate(), 20)};
|
|
|
|
|
static const unsigned min_samples = 4000;
|
|
|
|
|
static const unsigned min_ext_samples = 0;
|
|
|
|
|
v8::CpuProfile* profile =
|
|
|
|
|
helper.Run(function, args, arraysize(args), min_samples, min_ext_samples,
|
|
|
|
|
v8::CpuProfilingMode::kCallerLineNumbers);
|
2019-01-02 12:19:06 +00:00
|
|
|
CHECK(profile);
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2020-01-02 13:27:34 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
2019-01-02 12:19:06 +00:00
|
|
|
|
2019-04-30 11:04:41 +00:00
|
|
|
NameLinePair l421_a17[] = {{"level1", 27},
|
|
|
|
|
{"level2", 23},
|
|
|
|
|
{"level3", 17},
|
|
|
|
|
{"level4", 12},
|
|
|
|
|
{"action", 8}};
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CheckBranch(start_node, l421_a17, arraysize(l421_a17));
|
2019-04-30 11:04:41 +00:00
|
|
|
NameLinePair l422_a17[] = {{"level1", 27},
|
|
|
|
|
{"level2", 23},
|
|
|
|
|
{"level3", 17},
|
|
|
|
|
{"level4", 13},
|
|
|
|
|
{"action", 8}};
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CheckBranch(start_node, l422_a17, arraysize(l422_a17));
|
|
|
|
|
|
2019-04-30 11:04:41 +00:00
|
|
|
NameLinePair l421_a18[] = {{"level1", 27},
|
|
|
|
|
{"level2", 23},
|
|
|
|
|
{"level3", 17},
|
|
|
|
|
{"level4", 12},
|
|
|
|
|
{"action", 9}};
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CheckBranch(start_node, l421_a18, arraysize(l421_a18));
|
2019-04-30 11:04:41 +00:00
|
|
|
NameLinePair l422_a18[] = {{"level1", 27},
|
|
|
|
|
{"level2", 23},
|
|
|
|
|
{"level3", 17},
|
|
|
|
|
{"level4", 13},
|
|
|
|
|
{"action", 9}};
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CheckBranch(start_node, l422_a18, arraysize(l422_a18));
|
|
|
|
|
|
2019-04-30 11:04:41 +00:00
|
|
|
NameLinePair action_direct[] = {{"level1", 27}, {"action", 21}};
|
2019-01-02 12:19:06 +00:00
|
|
|
CheckBranch(start_node, action_direct, arraysize(action_direct));
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-13 14:45:14 +00:00
|
|
|
static const char* cross_script_source_a = R"(
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
%NeverOptimizeFunction(action);
|
|
|
|
|
function action(n) {
|
|
|
|
|
var s = 0;
|
|
|
|
|
for (var i = 0; i < n; ++i) s += i*i*i;
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
function level1() {
|
|
|
|
|
const a = action(1);
|
|
|
|
|
const b = action(200);
|
|
|
|
|
const c = action(1);
|
|
|
|
|
return a + b + c;
|
|
|
|
|
}
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
static const char* cross_script_source_b = R"(
|
|
|
|
|
%PrepareFunctionForOptimization(start);
|
|
|
|
|
%PrepareFunctionForOptimization(level1);
|
|
|
|
|
start(1);
|
|
|
|
|
start(1);
|
|
|
|
|
%OptimizeFunctionOnNextCall(start);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level1);
|
|
|
|
|
start(1);
|
|
|
|
|
function start(n) {
|
|
|
|
|
while (--n)
|
|
|
|
|
level1();
|
|
|
|
|
};
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
TEST(CrossScriptInliningCallerLineNumbers) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2019-05-20 10:33:40 +00:00
|
|
|
v8::Isolate* isolate = CcTest::isolate();
|
2020-01-02 13:58:23 +00:00
|
|
|
LocalContext env;
|
2019-05-20 10:33:40 +00:00
|
|
|
v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);
|
|
|
|
|
v8::HandleScope scope(isolate);
|
2020-01-02 13:58:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2019-05-13 14:45:14 +00:00
|
|
|
|
|
|
|
|
v8::Local<v8::Script> script_a =
|
|
|
|
|
CompileWithOrigin(cross_script_source_a, "script_a", false);
|
|
|
|
|
v8::Local<v8::Script> script_b =
|
|
|
|
|
CompileWithOrigin(cross_script_source_b, "script_b", false);
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
script_a->Run(env.local()).ToLocalChecked();
|
|
|
|
|
script_b->Run(env.local()).ToLocalChecked();
|
2019-05-13 14:45:14 +00:00
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2019-05-13 14:45:14 +00:00
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(env->GetIsolate(), 10)};
|
|
|
|
|
static const unsigned min_samples = 1000;
|
|
|
|
|
static const unsigned min_ext_samples = 0;
|
|
|
|
|
v8::CpuProfile* profile =
|
|
|
|
|
helper.Run(function, args, arraysize(args), min_samples, min_ext_samples,
|
|
|
|
|
v8::CpuProfilingMode::kCallerLineNumbers);
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK(profile);
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_b", start_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
|
|
|
|
NameLinePair l19_a10[] = {{"level1", 11}, {"action", 15}};
|
|
|
|
|
CheckBranch(start_node, l19_a10, arraysize(l19_a10));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* level1_node =
|
|
|
|
|
GetChild(env.local(), start_node, "level1");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_a", level1_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* action_node =
|
|
|
|
|
GetChild(env.local(), level1_node, "action");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_a", action_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
static const char* cross_script_source_c = R"(
|
|
|
|
|
function level3() {
|
|
|
|
|
const a = action(1);
|
|
|
|
|
const b = action(100);
|
|
|
|
|
const c = action(1);
|
|
|
|
|
return a + b + c;
|
|
|
|
|
}
|
|
|
|
|
%NeverOptimizeFunction(action);
|
|
|
|
|
function action(n) {
|
|
|
|
|
var s = 0;
|
|
|
|
|
for (var i = 0; i < n; ++i) s += i*i*i;
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
static const char* cross_script_source_d = R"(
|
|
|
|
|
function level2() {
|
|
|
|
|
const p = level3();
|
|
|
|
|
const q = level3();
|
|
|
|
|
return p + q;
|
|
|
|
|
}
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
static const char* cross_script_source_e = R"(
|
|
|
|
|
function level1() {
|
|
|
|
|
return level2() + 1000;
|
|
|
|
|
}
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
static const char* cross_script_source_f = R"(
|
|
|
|
|
%PrepareFunctionForOptimization(start);
|
|
|
|
|
%PrepareFunctionForOptimization(level1);
|
|
|
|
|
%PrepareFunctionForOptimization(level2);
|
|
|
|
|
%PrepareFunctionForOptimization(level3);
|
|
|
|
|
start(1);
|
|
|
|
|
start(1);
|
|
|
|
|
%OptimizeFunctionOnNextCall(start);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level1);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level2);
|
|
|
|
|
%OptimizeFunctionOnNextCall(level3);
|
|
|
|
|
start(1);
|
|
|
|
|
function start(n) {
|
|
|
|
|
while (--n)
|
|
|
|
|
level1();
|
|
|
|
|
};
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
TEST(CrossScriptInliningCallerLineNumbers2) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2020-01-02 13:58:23 +00:00
|
|
|
LocalContext env;
|
2019-05-13 14:45:14 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2020-01-02 13:58:23 +00:00
|
|
|
ProfilerHelper helper(env.local());
|
2019-05-13 14:45:14 +00:00
|
|
|
|
|
|
|
|
v8::Local<v8::Script> script_c =
|
|
|
|
|
CompileWithOrigin(cross_script_source_c, "script_c", false);
|
|
|
|
|
v8::Local<v8::Script> script_d =
|
|
|
|
|
CompileWithOrigin(cross_script_source_d, "script_d", false);
|
|
|
|
|
v8::Local<v8::Script> script_e =
|
|
|
|
|
CompileWithOrigin(cross_script_source_e, "script_e", false);
|
|
|
|
|
v8::Local<v8::Script> script_f =
|
|
|
|
|
CompileWithOrigin(cross_script_source_f, "script_f", false);
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
script_c->Run(env.local()).ToLocalChecked();
|
|
|
|
|
script_d->Run(env.local()).ToLocalChecked();
|
|
|
|
|
script_e->Run(env.local()).ToLocalChecked();
|
|
|
|
|
script_f->Run(env.local()).ToLocalChecked();
|
2019-05-13 14:45:14 +00:00
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
2019-05-13 14:45:14 +00:00
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
v8::Local<v8::Value> args[] = {v8::Integer::New(env->GetIsolate(), 10)};
|
|
|
|
|
static const unsigned min_samples = 1000;
|
|
|
|
|
static const unsigned min_ext_samples = 0;
|
|
|
|
|
v8::CpuProfile* profile =
|
|
|
|
|
helper.Run(function, args, arraysize(args), min_samples, min_ext_samples,
|
|
|
|
|
v8::CpuProfilingMode::kCallerLineNumbers);
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK(profile);
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_f", start_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* level1_node =
|
|
|
|
|
GetChild(env.local(), start_node, "level1");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_e", level1_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* level2_node =
|
|
|
|
|
GetChild(env.local(), level1_node, "level2");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_d", level2_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* level3_node =
|
|
|
|
|
GetChild(env.local(), level2_node, "level3");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_c", level3_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
2020-01-02 13:58:23 +00:00
|
|
|
const v8::CpuProfileNode* action_node =
|
|
|
|
|
GetChild(env.local(), level3_node, "action");
|
2019-05-13 14:45:14 +00:00
|
|
|
CHECK_EQ(0, strcmp("script_c", action_node->GetScriptResourceNameStr()));
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2013-08-07 17:04:27 +00:00
|
|
|
// [Top down]:
|
2016-01-26 20:47:23 +00:00
|
|
|
// 0 (root) #0 1
|
|
|
|
|
// 2 (program) #0 2
|
|
|
|
|
// 3 (idle) #0 3
|
2013-08-07 17:04:27 +00:00
|
|
|
TEST(IdleTime) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfiler* cpu_profiler = v8::CpuProfiler::New(env->GetIsolate());
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2015-02-06 16:50:56 +00:00
|
|
|
v8::Local<v8::String> profile_name = v8_str("my_profile");
|
2014-03-28 09:24:49 +00:00
|
|
|
cpu_profiler->StartProfiling(profile_name);
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2013-09-19 09:17:13 +00:00
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
2016-07-08 15:00:23 +00:00
|
|
|
i::ProfilerEventsProcessor* processor =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(cpu_profiler)->processor();
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2018-10-17 12:09:34 +00:00
|
|
|
processor->AddCurrentStack(true);
|
2018-03-06 13:52:53 +00:00
|
|
|
isolate->SetIdle(true);
|
2013-08-07 17:04:27 +00:00
|
|
|
for (int i = 0; i < 3; i++) {
|
2018-10-17 12:09:34 +00:00
|
|
|
processor->AddCurrentStack(true);
|
2013-08-07 17:04:27 +00:00
|
|
|
}
|
2018-03-06 13:52:53 +00:00
|
|
|
isolate->SetIdle(false);
|
2018-10-17 12:09:34 +00:00
|
|
|
processor->AddCurrentStack(true);
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
v8::CpuProfile* profile = cpu_profiler->StopProfiling(profile_name);
|
2015-01-30 09:29:25 +00:00
|
|
|
CHECK(profile);
|
2013-08-07 17:04:27 +00:00
|
|
|
// Dump collected profile to have a better diagnostic in case of failure.
|
2014-03-28 09:24:49 +00:00
|
|
|
reinterpret_cast<i::CpuProfile*>(profile)->Print();
|
2013-08-07 17:04:27 +00:00
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* program_node =
|
2016-06-22 16:43:46 +00:00
|
|
|
GetChild(env.local(), root, CodeEntry::kProgramEntryName);
|
2016-02-08 18:12:04 +00:00
|
|
|
CHECK_EQ(0, program_node->GetChildrenCount());
|
|
|
|
|
CHECK_GE(program_node->GetHitCount(), 2u);
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2016-02-08 18:12:04 +00:00
|
|
|
const v8::CpuProfileNode* idle_node =
|
2016-06-22 16:43:46 +00:00
|
|
|
GetChild(env.local(), root, CodeEntry::kIdleEntryName);
|
2016-02-08 18:12:04 +00:00
|
|
|
CHECK_EQ(0, idle_node->GetChildrenCount());
|
|
|
|
|
CHECK_GE(idle_node->GetHitCount(), 3u);
|
2013-08-07 17:04:27 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
profile->Delete();
|
2016-07-08 15:00:23 +00:00
|
|
|
cpu_profiler->Dispose();
|
2013-08-07 17:04:27 +00:00
|
|
|
}
|
2013-10-10 13:15:47 +00:00
|
|
|
|
2013-11-22 12:43:17 +00:00
|
|
|
static void CheckFunctionDetails(v8::Isolate* isolate,
|
|
|
|
|
const v8::CpuProfileNode* node,
|
|
|
|
|
const char* name, const char* script_name,
|
2019-03-07 18:54:37 +00:00
|
|
|
bool is_shared_cross_origin, int script_id,
|
2019-03-15 19:42:03 +00:00
|
|
|
int line, int column,
|
|
|
|
|
const v8::CpuProfileNode* parent) {
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Context> context = isolate->GetCurrentContext();
|
|
|
|
|
CHECK(v8_str(name)->Equals(context, node->GetFunctionName()).FromJust());
|
2016-09-09 15:50:23 +00:00
|
|
|
CHECK_EQ(0, strcmp(name, node->GetFunctionNameStr()));
|
2015-12-08 18:44:23 +00:00
|
|
|
CHECK(v8_str(script_name)
|
|
|
|
|
->Equals(context, node->GetScriptResourceName())
|
|
|
|
|
.FromJust());
|
2016-09-09 15:50:23 +00:00
|
|
|
CHECK_EQ(0, strcmp(script_name, node->GetScriptResourceNameStr()));
|
2013-10-10 13:15:47 +00:00
|
|
|
CHECK_EQ(script_id, node->GetScriptId());
|
|
|
|
|
CHECK_EQ(line, node->GetLineNumber());
|
|
|
|
|
CHECK_EQ(column, node->GetColumnNumber());
|
2019-03-15 19:42:03 +00:00
|
|
|
CHECK_EQ(parent, node->GetParent());
|
2019-04-03 00:07:48 +00:00
|
|
|
CHECK_EQ(v8::CpuProfileNode::kScript, node->GetSourceType());
|
2013-10-10 13:15:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(FunctionDetails) {
|
2016-02-08 18:12:04 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
2013-10-10 13:15:47 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> script_a = CompileWithOrigin(
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(foo);\n"
|
|
|
|
|
"%NeverOptimizeFunction(bar);\n"
|
|
|
|
|
" function foo\n() { bar(); }\n"
|
2015-12-08 18:44:23 +00:00
|
|
|
" function bar() { startProfiling(); }\n",
|
2019-03-07 18:54:37 +00:00
|
|
|
"script_a", false);
|
2015-12-08 18:44:23 +00:00
|
|
|
script_a->Run(env).ToLocalChecked();
|
|
|
|
|
v8::Local<v8::Script> script_b = CompileWithOrigin(
|
2016-02-08 18:12:04 +00:00
|
|
|
"%NeverOptimizeFunction(baz);"
|
|
|
|
|
"\n\n function baz() { foo(); }\n"
|
2015-12-08 18:44:23 +00:00
|
|
|
"\n\nbaz();\n"
|
|
|
|
|
"stopProfiling();\n",
|
2019-03-07 18:54:37 +00:00
|
|
|
"script_b", true);
|
2015-12-08 18:44:23 +00:00
|
|
|
script_b->Run(env).ToLocalChecked();
|
2014-01-17 10:52:00 +00:00
|
|
|
const v8::CpuProfile* profile = i::ProfilerExtension::last_profile;
|
2013-10-10 13:15:47 +00:00
|
|
|
const v8::CpuProfileNode* current = profile->GetTopDownRoot();
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
reinterpret_cast<ProfileNode*>(const_cast<v8::CpuProfileNode*>(current))
|
|
|
|
|
->Print(0);
|
2013-10-10 13:15:47 +00:00
|
|
|
// The tree should look like this:
|
|
|
|
|
// 0 (root) 0 #1
|
2014-08-05 07:08:39 +00:00
|
|
|
// 0 "" 19 #2 no reason script_b:1
|
2013-10-10 13:15:47 +00:00
|
|
|
// 0 baz 19 #3 TryCatchStatement script_b:3
|
|
|
|
|
// 0 foo 18 #4 TryCatchStatement script_a:2
|
|
|
|
|
// 1 bar 18 #5 no reason script_a:3
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2019-03-15 19:42:03 +00:00
|
|
|
CHECK_EQ(root->GetParent(), nullptr);
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* script = GetChild(env, root, "");
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), script, "", "script_b", true,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_b->GetUnboundScript()->GetId(), 1, 1, root);
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* baz = GetChild(env, script, "baz");
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), baz, "baz", "script_b", true,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_b->GetUnboundScript()->GetId(), 3, 16, script);
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* foo = GetChild(env, baz, "foo");
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), foo, "foo", "script_a", false,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_a->GetUnboundScript()->GetId(), 4, 1, baz);
|
2015-12-08 18:44:23 +00:00
|
|
|
const v8::CpuProfileNode* bar = GetChild(env, foo, "bar");
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), bar, "bar", "script_a", false,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_a->GetUnboundScript()->GetId(), 5, 14, foo);
|
2013-10-10 13:15:47 +00:00
|
|
|
}
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2018-01-03 11:11:11 +00:00
|
|
|
TEST(FunctionDetailsInlining) {
|
|
|
|
|
if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2018-01-03 11:11:11 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
|
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
|
|
|
|
|
// alpha is in a_script, beta in b_script. beta is
|
|
|
|
|
// inlined in alpha, but it should be attributed to b_script.
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::Script> script_b = CompileWithOrigin(
|
|
|
|
|
"function beta(k) {\n"
|
|
|
|
|
" let sum = 2;\n"
|
|
|
|
|
" for(let i = 0; i < k; i ++) {\n"
|
|
|
|
|
" sum += i;\n"
|
|
|
|
|
" sum = sum + 'a';\n"
|
|
|
|
|
" }\n"
|
|
|
|
|
" return sum;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"\n",
|
2019-03-07 18:54:37 +00:00
|
|
|
"script_b", true);
|
2018-01-03 11:11:11 +00:00
|
|
|
|
|
|
|
|
v8::Local<v8::Script> script_a = CompileWithOrigin(
|
|
|
|
|
"function alpha(p) {\n"
|
|
|
|
|
" let res = beta(p);\n"
|
|
|
|
|
" res = res + res;\n"
|
|
|
|
|
" return res;\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"let p = 2;\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"// Warm up before profiling or the inlining doesn't happen.\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(alpha);\n"
|
2018-01-03 11:11:11 +00:00
|
|
|
"p = alpha(p);\n"
|
|
|
|
|
"p = alpha(p);\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(alpha);\n"
|
|
|
|
|
"p = alpha(p);\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"startProfiling();\n"
|
|
|
|
|
"for(let i = 0; i < 10000; i++) {\n"
|
|
|
|
|
" p = alpha(p);\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"stopProfiling();\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"\n",
|
2019-03-07 18:54:37 +00:00
|
|
|
"script_a", false);
|
2018-01-03 11:11:11 +00:00
|
|
|
|
|
|
|
|
script_b->Run(env).ToLocalChecked();
|
|
|
|
|
script_a->Run(env).ToLocalChecked();
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfile* profile = i::ProfilerExtension::last_profile;
|
|
|
|
|
const v8::CpuProfileNode* current = profile->GetTopDownRoot();
|
|
|
|
|
reinterpret_cast<ProfileNode*>(const_cast<v8::CpuProfileNode*>(current))
|
|
|
|
|
->Print(0);
|
|
|
|
|
// The tree should look like this:
|
|
|
|
|
// 0 (root) 0 #1
|
|
|
|
|
// 5 (program) 0 #6
|
|
|
|
|
// 2 14 #2 script_a:1
|
|
|
|
|
// ;;; deopted at script_id: 14 position: 299 with reason 'Insufficient
|
|
|
|
|
// type feedback for call'.
|
|
|
|
|
// 1 alpha 14 #4 script_a:1
|
|
|
|
|
// 9 beta 13 #5 script_b:0
|
|
|
|
|
// 0 startProfiling 0 #3
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
2019-03-15 19:42:03 +00:00
|
|
|
CHECK_EQ(root->GetParent(), nullptr);
|
2018-01-03 11:11:11 +00:00
|
|
|
const v8::CpuProfileNode* script = GetChild(env, root, "");
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), script, "", "script_a", false,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_a->GetUnboundScript()->GetId(), 1, 1, root);
|
2018-01-03 11:11:11 +00:00
|
|
|
const v8::CpuProfileNode* alpha = FindChild(env, script, "alpha");
|
|
|
|
|
// Return early if profiling didn't sample alpha.
|
|
|
|
|
if (!alpha) return;
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), alpha, "alpha", "script_a", false,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_a->GetUnboundScript()->GetId(), 1, 15, script);
|
2018-01-03 11:11:11 +00:00
|
|
|
const v8::CpuProfileNode* beta = FindChild(env, alpha, "beta");
|
|
|
|
|
if (!beta) return;
|
2019-03-07 18:54:37 +00:00
|
|
|
CheckFunctionDetails(env->GetIsolate(), beta, "beta", "script_b", true,
|
2019-03-15 19:42:03 +00:00
|
|
|
script_b->GetUnboundScript()->GetId(), 1, 14, alpha);
|
2018-01-03 11:11:11 +00:00
|
|
|
}
|
2013-12-11 14:39:18 +00:00
|
|
|
|
|
|
|
|
TEST(DontStopOnFinishedProfileDelete) {
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2014-01-17 10:52:00 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2016-07-08 15:00:23 +00:00
|
|
|
v8::CpuProfiler* profiler = v8::CpuProfiler::New(env->GetIsolate());
|
2013-12-18 08:59:09 +00:00
|
|
|
i::CpuProfiler* iprofiler = reinterpret_cast<i::CpuProfiler*>(profiler);
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::String> outer = v8_str("outer");
|
2014-03-28 09:24:49 +00:00
|
|
|
profiler->StartProfiling(outer);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::String> inner = v8_str("inner");
|
2014-03-28 09:24:49 +00:00
|
|
|
profiler->StartProfiling(inner);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
v8::CpuProfile* inner_profile = profiler->StopProfiling(inner);
|
2013-12-11 14:39:18 +00:00
|
|
|
CHECK(inner_profile);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(1, iprofiler->GetProfilesCount());
|
2014-03-28 09:24:49 +00:00
|
|
|
inner_profile->Delete();
|
2017-10-13 16:33:03 +00:00
|
|
|
inner_profile = nullptr;
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2013-12-11 14:39:18 +00:00
|
|
|
|
2014-03-28 09:24:49 +00:00
|
|
|
v8::CpuProfile* outer_profile = profiler->StopProfiling(outer);
|
2013-12-11 14:39:18 +00:00
|
|
|
CHECK(outer_profile);
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(1, iprofiler->GetProfilesCount());
|
2014-03-28 09:24:49 +00:00
|
|
|
outer_profile->Delete();
|
2017-10-13 16:33:03 +00:00
|
|
|
outer_profile = nullptr;
|
2013-12-18 08:59:09 +00:00
|
|
|
CHECK_EQ(0, iprofiler->GetProfilesCount());
|
2016-07-08 15:00:23 +00:00
|
|
|
profiler->Dispose();
|
2013-12-11 14:39:18 +00:00
|
|
|
}
|
2015-02-10 14:32:42 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
const char* GetBranchDeoptReason(v8::Local<v8::Context> context,
|
|
|
|
|
i::CpuProfile* iprofile, const char* branch[],
|
2015-03-09 14:43:29 +00:00
|
|
|
int length) {
|
|
|
|
|
v8::CpuProfile* profile = reinterpret_cast<v8::CpuProfile*>(iprofile);
|
2017-10-13 16:33:03 +00:00
|
|
|
const ProfileNode* iopt_function = nullptr;
|
2015-12-08 18:44:23 +00:00
|
|
|
iopt_function = GetSimpleBranch(context, profile, branch, length);
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(1U, iopt_function->deopt_infos().size());
|
2015-03-09 14:43:29 +00:00
|
|
|
return iopt_function->deopt_infos()[0].deopt_reason;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-05 10:37:56 +00:00
|
|
|
// deopt at top function
|
2015-02-10 14:32:42 +00:00
|
|
|
TEST(CollectDeoptEvents) {
|
2017-04-28 15:36:46 +00:00
|
|
|
if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
|
2015-02-10 14:32:42 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2015-02-10 14:32:42 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
i::CpuProfiler* iprofiler =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(helper.profiler());
|
2015-02-10 14:32:42 +00:00
|
|
|
|
2015-03-09 14:43:29 +00:00
|
|
|
const char opt_source[] =
|
|
|
|
|
"function opt_function%d(value, depth) {\n"
|
|
|
|
|
" if (depth) return opt_function%d(value, depth - 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
" return 10 / value;\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"}\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"\n";
|
|
|
|
|
|
|
|
|
|
for (int i = 0; i < 3; ++i) {
|
|
|
|
|
i::EmbeddedVector<char, sizeof(opt_source) + 100> buffer;
|
|
|
|
|
i::SNPrintF(buffer, opt_source, i, i);
|
2019-04-29 11:06:49 +00:00
|
|
|
v8::Script::Compile(env, v8_str(buffer.begin()))
|
2015-12-08 18:44:23 +00:00
|
|
|
.ToLocalChecked()
|
|
|
|
|
->Run(env)
|
|
|
|
|
.ToLocalChecked();
|
2015-03-09 14:43:29 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const char* source =
|
|
|
|
|
"startProfiling();\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(opt_function0);\n"
|
|
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function0(1, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"%OptimizeFunctionOnNextCall(opt_function0)\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"opt_function0(1, 1);\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"opt_function0(undefined, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(opt_function1);\n"
|
|
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function1(1, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"%OptimizeFunctionOnNextCall(opt_function1)\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function1(1, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function1(NaN, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(opt_function2);\n"
|
|
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function2(1, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"%OptimizeFunctionOnNextCall(opt_function2)\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
2015-03-09 14:43:29 +00:00
|
|
|
"opt_function2(1, 1);\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"opt_function2(0, 1);\n"
|
2015-03-05 10:37:56 +00:00
|
|
|
"\n"
|
|
|
|
|
"stopProfiling();\n"
|
|
|
|
|
"\n";
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Script::Compile(env, v8_str(source))
|
|
|
|
|
.ToLocalChecked()
|
|
|
|
|
->Run(env)
|
|
|
|
|
.ToLocalChecked();
|
2015-02-10 14:32:42 +00:00
|
|
|
i::CpuProfile* iprofile = iprofiler->GetProfile(0);
|
|
|
|
|
iprofile->Print();
|
2015-03-24 12:46:13 +00:00
|
|
|
/* The expected profile
|
|
|
|
|
[Top down]:
|
|
|
|
|
0 (root) 0 #1
|
|
|
|
|
23 32 #2
|
|
|
|
|
1 opt_function2 31 #7
|
|
|
|
|
1 opt_function2 31 #8
|
|
|
|
|
;;; deopted at script_id: 31 position: 106 with reason
|
|
|
|
|
'division by zero'.
|
|
|
|
|
2 opt_function0 29 #3
|
|
|
|
|
4 opt_function0 29 #4
|
|
|
|
|
;;; deopted at script_id: 29 position: 108 with reason 'not a
|
|
|
|
|
heap number'.
|
|
|
|
|
0 opt_function1 30 #5
|
|
|
|
|
1 opt_function1 30 #6
|
|
|
|
|
;;; deopted at script_id: 30 position: 108 with reason 'lost
|
|
|
|
|
precision or NaN'.
|
|
|
|
|
*/
|
|
|
|
|
|
2015-03-09 14:43:29 +00:00
|
|
|
{
|
|
|
|
|
const char* branch[] = {"", "opt_function0", "opt_function0"};
|
2016-12-09 15:05:48 +00:00
|
|
|
const char* deopt_reason =
|
|
|
|
|
GetBranchDeoptReason(env, iprofile, branch, arraysize(branch));
|
|
|
|
|
if (deopt_reason != reason(i::DeoptimizeReason::kNotAHeapNumber) &&
|
|
|
|
|
deopt_reason != reason(i::DeoptimizeReason::kNotASmi)) {
|
2017-12-18 16:19:23 +00:00
|
|
|
FATAL("%s", deopt_reason);
|
2016-12-09 15:05:48 +00:00
|
|
|
}
|
2015-03-09 14:43:29 +00:00
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
const char* branch[] = {"", "opt_function1", "opt_function1"};
|
2015-03-10 10:45:07 +00:00
|
|
|
const char* deopt_reason =
|
2015-12-08 18:44:23 +00:00
|
|
|
GetBranchDeoptReason(env, iprofile, branch, arraysize(branch));
|
2016-07-18 09:23:28 +00:00
|
|
|
if (deopt_reason != reason(i::DeoptimizeReason::kNaN) &&
|
2016-12-09 15:05:48 +00:00
|
|
|
deopt_reason != reason(i::DeoptimizeReason::kLostPrecisionOrNaN) &&
|
|
|
|
|
deopt_reason != reason(i::DeoptimizeReason::kNotASmi)) {
|
2017-12-18 16:19:23 +00:00
|
|
|
FATAL("%s", deopt_reason);
|
2015-03-10 10:45:07 +00:00
|
|
|
}
|
2015-03-09 14:43:29 +00:00
|
|
|
}
|
|
|
|
|
{
|
|
|
|
|
const char* branch[] = {"", "opt_function2", "opt_function2"};
|
2016-07-18 09:23:28 +00:00
|
|
|
CHECK_EQ(reason(i::DeoptimizeReason::kDivisionByZero),
|
2015-12-08 18:44:23 +00:00
|
|
|
GetBranchDeoptReason(env, iprofile, branch, arraysize(branch)));
|
2015-03-09 14:43:29 +00:00
|
|
|
}
|
2015-02-10 14:32:42 +00:00
|
|
|
iprofiler->DeleteProfile(iprofile);
|
|
|
|
|
}
|
2015-02-19 10:07:46 +00:00
|
|
|
|
|
|
|
|
TEST(SourceLocation) {
|
|
|
|
|
i::FLAG_always_opt = true;
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
|
|
|
|
|
|
|
|
|
const char* source =
|
|
|
|
|
"function CompareStatementWithThis() {\n"
|
|
|
|
|
" if (this === 1) {}\n"
|
|
|
|
|
"}\n"
|
|
|
|
|
"CompareStatementWithThis();\n";
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Script::Compile(env.local(), v8_str(source))
|
|
|
|
|
.ToLocalChecked()
|
|
|
|
|
->Run(env.local())
|
|
|
|
|
.ToLocalChecked();
|
2015-02-19 10:07:46 +00:00
|
|
|
}
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
static const char* inlined_source =
|
2016-11-22 10:14:36 +00:00
|
|
|
"function opt_function(left, right) { var k = left*right; return k + 1; "
|
|
|
|
|
"}\n";
|
2015-03-24 12:46:13 +00:00
|
|
|
// 0.........1.........2.........3.........4....*....5.........6......*..7
|
|
|
|
|
|
|
|
|
|
// deopt at the first level inlined function
|
|
|
|
|
TEST(DeoptAtFirstLevelInlinedSource) {
|
2017-04-28 15:36:46 +00:00
|
|
|
if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
|
2015-03-24 12:46:13 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2015-03-24 12:46:13 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
i::CpuProfiler* iprofiler =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(helper.profiler());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
// 0.........1.........2.........3.........4.........5.........6.........7
|
|
|
|
|
const char* source =
|
2016-11-22 10:14:36 +00:00
|
|
|
"function test(left, right) { return opt_function(left, right); }\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"startProfiling();\n"
|
|
|
|
|
"\n"
|
2019-07-11 08:33:47 +00:00
|
|
|
"%EnsureFeedbackVectorForFunction(opt_function);\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(test);\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test(10, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(test)\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test(10, 10);\n"
|
|
|
|
|
"\n"
|
|
|
|
|
"test(undefined, 1e9);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"stopProfiling();\n"
|
|
|
|
|
"\n";
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> inlined_script = v8_compile(inlined_source);
|
|
|
|
|
inlined_script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
int inlined_script_id = inlined_script->GetUnboundScript()->GetId();
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> script = v8_compile(source);
|
|
|
|
|
script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
int script_id = script->GetUnboundScript()->GetId();
|
|
|
|
|
|
|
|
|
|
i::CpuProfile* iprofile = iprofiler->GetProfile(0);
|
|
|
|
|
iprofile->Print();
|
|
|
|
|
/* The expected profile output
|
|
|
|
|
[Top down]:
|
|
|
|
|
0 (root) 0 #1
|
|
|
|
|
10 30 #2
|
|
|
|
|
1 test 30 #3
|
|
|
|
|
;;; deopted at script_id: 29 position: 45 with reason 'not a
|
|
|
|
|
heap number'.
|
|
|
|
|
;;; Inline point: script_id 30 position: 36.
|
|
|
|
|
4 opt_function 29 #4
|
|
|
|
|
*/
|
|
|
|
|
v8::CpuProfile* profile = reinterpret_cast<v8::CpuProfile*>(iprofile);
|
|
|
|
|
|
|
|
|
|
const char* branch[] = {"", "test"};
|
|
|
|
|
const ProfileNode* itest_node =
|
2015-12-08 18:44:23 +00:00
|
|
|
GetSimpleBranch(env, profile, branch, arraysize(branch));
|
2015-04-08 16:13:24 +00:00
|
|
|
const std::vector<v8::CpuProfileDeoptInfo>& deopt_infos =
|
|
|
|
|
itest_node->deopt_infos();
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(1U, deopt_infos.size());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
2015-04-08 16:13:24 +00:00
|
|
|
const v8::CpuProfileDeoptInfo& info = deopt_infos[0];
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK(reason(i::DeoptimizeReason::kNotASmi) == info.deopt_reason ||
|
|
|
|
|
reason(i::DeoptimizeReason::kNotAHeapNumber) == info.deopt_reason);
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(2U, info.stack.size());
|
2015-03-24 12:46:13 +00:00
|
|
|
CHECK_EQ(inlined_script_id, info.stack[0].script_id);
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK_LE(dist(offset(inlined_source, "*right"), info.stack[0].position), 1);
|
2015-03-24 12:46:13 +00:00
|
|
|
CHECK_EQ(script_id, info.stack[1].script_id);
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK_EQ(offset(source, "opt_function(left,"), info.stack[1].position);
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
iprofiler->DeleteProfile(iprofile);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// deopt at the second level inlined function
|
|
|
|
|
TEST(DeoptAtSecondLevelInlinedSource) {
|
2017-04-28 15:36:46 +00:00
|
|
|
if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
|
2015-03-24 12:46:13 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2015-03-24 12:46:13 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
i::CpuProfiler* iprofiler =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(helper.profiler());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
// 0.........1.........2.........3.........4.........5.........6.........7
|
|
|
|
|
const char* source =
|
2016-11-22 10:14:36 +00:00
|
|
|
"function test2(left, right) { return opt_function(left, right); }\n"
|
|
|
|
|
"function test1(left, right) { return test2(left, right); } \n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"startProfiling();\n"
|
|
|
|
|
"\n"
|
2019-05-08 15:54:26 +00:00
|
|
|
"%EnsureFeedbackVectorForFunction(opt_function);\n"
|
|
|
|
|
"%EnsureFeedbackVectorForFunction(test2);\n"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(test1);\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test1(10, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(test1)\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test1(10, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test1(undefined, 1e9);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"stopProfiling();\n"
|
|
|
|
|
"\n";
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> inlined_script = v8_compile(inlined_source);
|
|
|
|
|
inlined_script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
int inlined_script_id = inlined_script->GetUnboundScript()->GetId();
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> script = v8_compile(source);
|
|
|
|
|
script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
int script_id = script->GetUnboundScript()->GetId();
|
|
|
|
|
|
|
|
|
|
i::CpuProfile* iprofile = iprofiler->GetProfile(0);
|
|
|
|
|
iprofile->Print();
|
|
|
|
|
/* The expected profile output
|
|
|
|
|
[Top down]:
|
|
|
|
|
0 (root) 0 #1
|
|
|
|
|
11 30 #2
|
|
|
|
|
1 test1 30 #3
|
|
|
|
|
;;; deopted at script_id: 29 position: 45 with reason 'not a
|
|
|
|
|
heap number'.
|
|
|
|
|
;;; Inline point: script_id 30 position: 37.
|
|
|
|
|
;;; Inline point: script_id 30 position: 103.
|
|
|
|
|
1 test2 30 #4
|
|
|
|
|
3 opt_function 29 #5
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
v8::CpuProfile* profile = reinterpret_cast<v8::CpuProfile*>(iprofile);
|
|
|
|
|
|
|
|
|
|
const char* branch[] = {"", "test1"};
|
|
|
|
|
const ProfileNode* itest_node =
|
2015-12-08 18:44:23 +00:00
|
|
|
GetSimpleBranch(env, profile, branch, arraysize(branch));
|
2015-04-08 16:13:24 +00:00
|
|
|
const std::vector<v8::CpuProfileDeoptInfo>& deopt_infos =
|
|
|
|
|
itest_node->deopt_infos();
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(1U, deopt_infos.size());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
2015-04-08 16:13:24 +00:00
|
|
|
const v8::CpuProfileDeoptInfo info = deopt_infos[0];
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK(reason(i::DeoptimizeReason::kNotASmi) == info.deopt_reason ||
|
|
|
|
|
reason(i::DeoptimizeReason::kNotAHeapNumber) == info.deopt_reason);
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(3U, info.stack.size());
|
2015-03-24 12:46:13 +00:00
|
|
|
CHECK_EQ(inlined_script_id, info.stack[0].script_id);
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK_LE(dist(offset(inlined_source, "*right"), info.stack[0].position), 1);
|
2015-03-24 12:46:13 +00:00
|
|
|
CHECK_EQ(script_id, info.stack[1].script_id);
|
2016-11-22 10:14:36 +00:00
|
|
|
CHECK_EQ(offset(source, "opt_function(left,"), info.stack[1].position);
|
|
|
|
|
CHECK_EQ(offset(source, "test2(left, right);"), info.stack[2].position);
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
iprofiler->DeleteProfile(iprofile);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// deopt in untracked function
|
|
|
|
|
TEST(DeoptUntrackedFunction) {
|
2017-04-28 15:36:46 +00:00
|
|
|
if (!CcTest::i_isolate()->use_optimizer() || i::FLAG_always_opt) return;
|
2015-03-24 12:46:13 +00:00
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2015-03-24 12:46:13 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
2016-07-08 15:00:23 +00:00
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
i::CpuProfiler* iprofiler =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(helper.profiler());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
// 0.........1.........2.........3.........4.........5.........6.........7
|
|
|
|
|
const char* source =
|
|
|
|
|
"function test(left, right) { return opt_function(left, right); }\n"
|
|
|
|
|
"\n"
|
2019-05-08 15:54:26 +00:00
|
|
|
"%EnsureFeedbackVectorForFunction(opt_function);"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(test);\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test(10, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(test)\n"
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test(10, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"startProfiling();\n" // profiler started after compilation.
|
|
|
|
|
"\n"
|
2016-11-22 10:14:36 +00:00
|
|
|
"test(undefined, 10);\n"
|
2015-03-24 12:46:13 +00:00
|
|
|
"\n"
|
|
|
|
|
"stopProfiling();\n"
|
|
|
|
|
"\n";
|
|
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> inlined_script = v8_compile(inlined_source);
|
|
|
|
|
inlined_script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
|
2015-12-08 18:44:23 +00:00
|
|
|
v8::Local<v8::Script> script = v8_compile(source);
|
|
|
|
|
script->Run(env).ToLocalChecked();
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
i::CpuProfile* iprofile = iprofiler->GetProfile(0);
|
|
|
|
|
iprofile->Print();
|
|
|
|
|
v8::CpuProfile* profile = reinterpret_cast<v8::CpuProfile*>(iprofile);
|
|
|
|
|
|
|
|
|
|
const char* branch[] = {"", "test"};
|
|
|
|
|
const ProfileNode* itest_node =
|
2015-12-08 18:44:23 +00:00
|
|
|
GetSimpleBranch(env, profile, branch, arraysize(branch));
|
2015-04-10 13:59:39 +00:00
|
|
|
CHECK_EQ(0U, itest_node->deopt_infos().size());
|
2015-03-24 12:46:13 +00:00
|
|
|
|
|
|
|
|
iprofiler->DeleteProfile(iprofile);
|
|
|
|
|
}
|
2016-10-06 18:14:03 +00:00
|
|
|
|
|
|
|
|
using v8::platform::tracing::TraceBuffer;
|
|
|
|
|
using v8::platform::tracing::TraceConfig;
|
|
|
|
|
using v8::platform::tracing::TraceObject;
|
|
|
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
|
2019-08-05 14:57:31 +00:00
|
|
|
#ifdef V8_USE_PERFETTO
|
|
|
|
|
class CpuProfilerListener : public platform::tracing::TraceEventListener {
|
|
|
|
|
public:
|
|
|
|
|
void ProcessPacket(const ::perfetto::protos::TracePacket& packet) {
|
2020-04-17 20:46:18 +00:00
|
|
|
auto& seq_state = sequence_state_[packet.trusted_packet_sequence_id()];
|
|
|
|
|
if (packet.incremental_state_cleared()) seq_state = SequenceState{};
|
|
|
|
|
|
|
|
|
|
if (!packet.has_track_event()) return;
|
|
|
|
|
|
|
|
|
|
// Update incremental state.
|
|
|
|
|
if (packet.has_interned_data()) {
|
|
|
|
|
const auto& interned_data = packet.interned_data();
|
|
|
|
|
for (const auto& it : interned_data.event_names()) {
|
|
|
|
|
CHECK_EQ(seq_state.event_names_.find(it.iid()),
|
|
|
|
|
seq_state.event_names_.end());
|
|
|
|
|
seq_state.event_names_[it.iid()] = it.name();
|
|
|
|
|
}
|
2019-08-05 14:57:31 +00:00
|
|
|
}
|
2020-04-17 20:46:18 +00:00
|
|
|
const auto& track_event = packet.track_event();
|
|
|
|
|
auto name = seq_state.event_names_[track_event.name_iid()];
|
|
|
|
|
if (name != "Profile" && name != "ProfileChunk") return;
|
|
|
|
|
|
|
|
|
|
CHECK_EQ(1, track_event.debug_annotations_size());
|
|
|
|
|
CHECK(track_event.debug_annotations()[0].has_legacy_json_value());
|
|
|
|
|
CHECK(!profile_id_ ||
|
|
|
|
|
track_event.legacy_event().unscoped_id() == profile_id_);
|
|
|
|
|
profile_id_ = track_event.legacy_event().unscoped_id();
|
|
|
|
|
result_json_ += result_json_.empty() ? "[" : ",\n";
|
|
|
|
|
result_json_ += track_event.debug_annotations()[0].legacy_json_value();
|
2019-08-05 14:57:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const std::string& result_json() {
|
|
|
|
|
result_json_ += "]";
|
|
|
|
|
return result_json_;
|
|
|
|
|
}
|
|
|
|
|
void Reset() {
|
|
|
|
|
result_json_.clear();
|
|
|
|
|
profile_id_ = 0;
|
2020-04-17 20:46:18 +00:00
|
|
|
sequence_state_.clear();
|
2019-08-05 14:57:31 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
std::string result_json_;
|
|
|
|
|
uint64_t profile_id_ = 0;
|
2020-04-17 20:46:18 +00:00
|
|
|
|
|
|
|
|
struct SequenceState {
|
|
|
|
|
std::map<uint64_t, std::string> event_names_;
|
|
|
|
|
};
|
|
|
|
|
std::map<uint32_t, SequenceState> sequence_state_;
|
2019-08-05 14:57:31 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
#else
|
|
|
|
|
|
2016-10-06 18:14:03 +00:00
|
|
|
class CpuProfileEventChecker : public v8::platform::tracing::TraceWriter {
|
|
|
|
|
public:
|
|
|
|
|
void AppendTraceEvent(TraceObject* trace_event) override {
|
2016-10-20 17:46:54 +00:00
|
|
|
if (trace_event->name() != std::string("Profile") &&
|
|
|
|
|
trace_event->name() != std::string("ProfileChunk"))
|
2016-10-06 18:14:03 +00:00
|
|
|
return;
|
|
|
|
|
CHECK(!profile_id_ || trace_event->id() == profile_id_);
|
|
|
|
|
CHECK_EQ(1, trace_event->num_args());
|
|
|
|
|
CHECK_EQ(TRACE_VALUE_TYPE_CONVERTABLE, trace_event->arg_types()[0]);
|
|
|
|
|
profile_id_ = trace_event->id();
|
|
|
|
|
v8::ConvertableToTraceFormat* arg =
|
|
|
|
|
trace_event->arg_convertables()[0].get();
|
2019-02-07 22:52:20 +00:00
|
|
|
result_json_ += result_json_.empty() ? "[" : ",\n";
|
2016-10-06 18:14:03 +00:00
|
|
|
arg->AppendAsTraceFormat(&result_json_);
|
|
|
|
|
}
|
2019-02-07 22:52:20 +00:00
|
|
|
void Flush() override { result_json_ += "]"; }
|
2016-10-06 18:14:03 +00:00
|
|
|
|
2019-02-07 22:52:20 +00:00
|
|
|
const std::string& result_json() const { return result_json_; }
|
|
|
|
|
void Reset() {
|
|
|
|
|
result_json_.clear();
|
|
|
|
|
profile_id_ = 0;
|
|
|
|
|
}
|
2016-10-06 18:14:03 +00:00
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
std::string result_json_;
|
|
|
|
|
uint64_t profile_id_ = 0;
|
|
|
|
|
};
|
|
|
|
|
|
2019-08-05 14:57:31 +00:00
|
|
|
#endif // !V8_USE_PERFETTO
|
|
|
|
|
|
2016-10-06 18:14:03 +00:00
|
|
|
} // namespace
|
|
|
|
|
|
|
|
|
|
TEST(TracingCpuProfiler) {
|
2019-02-07 22:52:20 +00:00
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
|
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
|
|
|
|
v8::Context::Scope context_scope(env);
|
2016-10-06 18:14:03 +00:00
|
|
|
|
2019-02-07 22:52:20 +00:00
|
|
|
auto* tracing_controller =
|
|
|
|
|
static_cast<v8::platform::tracing::TracingController*>(
|
|
|
|
|
i::V8::GetCurrentPlatform()->GetTracingController());
|
2016-10-06 18:14:03 +00:00
|
|
|
|
2019-05-23 10:44:11 +00:00
|
|
|
#ifdef V8_USE_PERFETTO
|
|
|
|
|
std::ostringstream perfetto_output;
|
|
|
|
|
tracing_controller->InitializeForPerfetto(&perfetto_output);
|
2019-08-05 14:57:31 +00:00
|
|
|
CpuProfilerListener listener;
|
|
|
|
|
tracing_controller->SetTraceEventListenerForTesting(&listener);
|
|
|
|
|
#else
|
|
|
|
|
CpuProfileEventChecker* event_checker = new CpuProfileEventChecker();
|
|
|
|
|
TraceBuffer* ring_buffer =
|
|
|
|
|
TraceBuffer::CreateTraceBufferRingBuffer(1, event_checker);
|
|
|
|
|
tracing_controller->Initialize(ring_buffer);
|
2019-05-23 10:44:11 +00:00
|
|
|
#endif
|
|
|
|
|
|
2019-02-07 22:52:20 +00:00
|
|
|
bool result = false;
|
|
|
|
|
for (int run_duration = 50; !result; run_duration += 50) {
|
|
|
|
|
TraceConfig* trace_config = new TraceConfig();
|
|
|
|
|
trace_config->AddIncludedCategory(
|
|
|
|
|
TRACE_DISABLED_BY_DEFAULT("v8.cpu_profiler"));
|
|
|
|
|
|
|
|
|
|
std::string test_code = R"(
|
|
|
|
|
function foo() {
|
|
|
|
|
let s = 0;
|
|
|
|
|
const endTime = Date.now() + )" +
|
|
|
|
|
std::to_string(run_duration) + R"(
|
|
|
|
|
while (Date.now() < endTime) s += Math.cos(s);
|
|
|
|
|
return s;
|
|
|
|
|
}
|
|
|
|
|
foo();)";
|
|
|
|
|
|
2017-11-13 13:16:49 +00:00
|
|
|
tracing_controller->StartTracing(trace_config);
|
2019-02-07 22:52:20 +00:00
|
|
|
CompileRun(test_code.c_str());
|
2020-04-17 20:46:18 +00:00
|
|
|
#ifdef V8_USE_PERFETTO
|
|
|
|
|
TrackEvent::Flush();
|
|
|
|
|
#endif
|
2017-11-13 13:16:49 +00:00
|
|
|
tracing_controller->StopTracing();
|
2019-02-07 22:52:20 +00:00
|
|
|
|
2019-08-05 14:57:31 +00:00
|
|
|
#ifdef V8_USE_PERFETTO
|
|
|
|
|
std::string profile_json = listener.result_json();
|
|
|
|
|
listener.Reset();
|
|
|
|
|
#else
|
2019-02-07 22:52:20 +00:00
|
|
|
std::string profile_json = event_checker->result_json();
|
|
|
|
|
event_checker->Reset();
|
2019-08-05 14:57:31 +00:00
|
|
|
#endif
|
2019-02-07 22:52:20 +00:00
|
|
|
CHECK_LT(0u, profile_json.length());
|
|
|
|
|
printf("Profile JSON: %s\n", profile_json.c_str());
|
|
|
|
|
|
|
|
|
|
std::string profile_checker_code = R"(
|
|
|
|
|
function checkProfile(json) {
|
|
|
|
|
const profile_header = json[0];
|
|
|
|
|
if (typeof profile_header['startTime'] !== 'number')
|
|
|
|
|
return false;
|
|
|
|
|
return json.some(event => (event.lines || []).some(line => line));
|
|
|
|
|
}
|
|
|
|
|
checkProfile()" + profile_json +
|
|
|
|
|
")";
|
|
|
|
|
result = CompileRunChecked(CcTest::isolate(), profile_checker_code.c_str())
|
|
|
|
|
->IsTrue();
|
2016-10-06 18:14:03 +00:00
|
|
|
}
|
|
|
|
|
|
2020-04-17 20:46:18 +00:00
|
|
|
#ifndef V8_USE_PERFETTO
|
2019-02-07 22:52:20 +00:00
|
|
|
static_cast<v8::platform::tracing::TracingController*>(
|
|
|
|
|
i::V8::GetCurrentPlatform()->GetTracingController())
|
|
|
|
|
->Initialize(nullptr);
|
2020-04-17 20:46:18 +00:00
|
|
|
#endif // !V8_USE_PERFETTO
|
2016-10-06 18:14:03 +00:00
|
|
|
}
|
2017-09-30 13:19:52 +00:00
|
|
|
|
2017-10-10 13:42:48 +00:00
|
|
|
TEST(Issue763073) {
|
|
|
|
|
class AllowNativesSyntax {
|
|
|
|
|
public:
|
|
|
|
|
AllowNativesSyntax()
|
|
|
|
|
: allow_natives_syntax_(i::FLAG_allow_natives_syntax),
|
|
|
|
|
trace_deopt_(i::FLAG_trace_deopt) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
i::FLAG_trace_deopt = true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
~AllowNativesSyntax() {
|
|
|
|
|
i::FLAG_allow_natives_syntax = allow_natives_syntax_;
|
|
|
|
|
i::FLAG_trace_deopt = trace_deopt_;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
private:
|
|
|
|
|
bool allow_natives_syntax_;
|
|
|
|
|
bool trace_deopt_;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
AllowNativesSyntax allow_natives_syntax_scope;
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
|
|
|
|
CompileRun(
|
|
|
|
|
"function f() { return function g(x) { }; }"
|
|
|
|
|
// Create first closure, optimize it, and deoptimize it.
|
|
|
|
|
"var g = f();"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(g);\n"
|
2017-10-10 13:42:48 +00:00
|
|
|
"g(1);"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(g);"
|
|
|
|
|
"g(1);"
|
|
|
|
|
"%DeoptimizeFunction(g);"
|
|
|
|
|
// Create second closure, and optimize it. This will create another
|
|
|
|
|
// optimized code object and put in the (shared) type feedback vector.
|
|
|
|
|
"var h = f();"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(h);\n"
|
2017-10-10 13:42:48 +00:00
|
|
|
"h(1);"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(h);"
|
|
|
|
|
"h(1);");
|
|
|
|
|
|
|
|
|
|
// Start profiling.
|
|
|
|
|
v8::CpuProfiler* cpu_profiler = v8::CpuProfiler::New(env->GetIsolate());
|
|
|
|
|
v8::Local<v8::String> profile_name = v8_str("test");
|
|
|
|
|
|
|
|
|
|
// Here we test that the heap iteration upon profiling start is not
|
|
|
|
|
// confused by having a deoptimized code object for a closure while
|
|
|
|
|
// having a different optimized code object in the type feedback vector.
|
|
|
|
|
cpu_profiler->StartProfiling(profile_name);
|
|
|
|
|
v8::CpuProfile* p = cpu_profiler->StopProfiling(profile_name);
|
|
|
|
|
p->Delete();
|
|
|
|
|
cpu_profiler->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-07 01:39:59 +00:00
|
|
|
static const char* js_collect_sample_api_source =
|
|
|
|
|
"%NeverOptimizeFunction(start);\n"
|
|
|
|
|
"function start() {\n"
|
|
|
|
|
" CallStaticCollectSample();\n"
|
|
|
|
|
"}";
|
|
|
|
|
|
|
|
|
|
static void CallStaticCollectSample(
|
|
|
|
|
const v8::FunctionCallbackInfo<v8::Value>& info) {
|
|
|
|
|
v8::CpuProfiler::CollectSample(info.GetIsolate());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(StaticCollectSampleAPI) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallStaticCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallStaticCollectSample"));
|
|
|
|
|
env->Global()
|
|
|
|
|
->Set(env.local(), v8_str("CallStaticCollectSample"), func)
|
|
|
|
|
.FromJust();
|
|
|
|
|
|
|
|
|
|
CompileRun(js_collect_sample_api_source);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
|
|
|
|
|
|
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 100);
|
|
|
|
|
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* start_node = GetChild(env.local(), root, "start");
|
|
|
|
|
GetChild(env.local(), start_node, "CallStaticCollectSample");
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-05 17:27:04 +00:00
|
|
|
TEST(CodeEntriesMemoryLeak) {
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2017-12-05 17:27:04 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
|
|
|
|
|
|
|
|
|
std::string source = "function start() {}\n";
|
|
|
|
|
for (int i = 0; i < 1000; ++i) {
|
|
|
|
|
source += "function foo" + std::to_string(i) + "() { return " +
|
|
|
|
|
std::to_string(i) +
|
|
|
|
|
"; }\n"
|
|
|
|
|
"foo" +
|
|
|
|
|
std::to_string(i) + "();\n";
|
|
|
|
|
}
|
|
|
|
|
CompileRun(source.c_str());
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "start");
|
|
|
|
|
|
|
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
|
|
|
|
|
for (int j = 0; j < 100; ++j) {
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0);
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2018-05-04 00:19:12 +00:00
|
|
|
i::CpuProfiler* profiler =
|
|
|
|
|
reinterpret_cast<i::CpuProfiler*>(helper.profiler());
|
|
|
|
|
CHECK(!profiler->profiler_listener_for_test());
|
2017-12-05 17:27:04 +00:00
|
|
|
}
|
|
|
|
|
|
2017-12-12 22:19:44 +00:00
|
|
|
TEST(NativeFrameStackTrace) {
|
|
|
|
|
// A test for issue https://crbug.com/768540
|
|
|
|
|
// When a sample lands in a native function which has not EXIT frame
|
|
|
|
|
// stack frame iterator used to bail out and produce an empty stack trace.
|
|
|
|
|
// The source code below makes v8 call the
|
[runtime] Move string table off-heap
Changes the isolate's string table into an off-heap structure. This
allows the string table to be resized without allocating on the V8 heap,
and potentially triggering a GC. This allows existing strings to be
inserted into the string table without requiring allocation.
This has two important benefits:
1) It allows the deserializer to insert strings directly into the
string table, rather than having to defer string insertion until
deserialization completes.
2) It simplifies the concurrent string table lookup to allow resizing
the table inside the write lock, therefore eliminating the race
where two concurrent lookups could both resize the table.
The off-heap string table has the following properties:
1) The general hashmap behaviour matches the HashTable, i.e. open
addressing, power-of-two sized, quadratic probing. This could, of
course, now be changed.
2) The empty and deleted sentinels are changed to Smi 0 and 1,
respectively, to make those comparisons a bit cheaper and not
require roots access.
3) When the HashTable is resized, the old elements array is kept
alive in a linked list of previous arrays, so that concurrent
lookups don't lose the data they're accessing. This linked list
is cleared by the GC, as then we know that all threads are in
a safepoint.
4) The GC treats the hash table entries as weak roots, and only walks
them for non-live reference clearing and for evacuation.
5) Since there is no longer a FixedArray to serialize for the startup
snapshot, there is now a custom serialization of the string table,
and the string table root is considered unserializable during weak
root iteration. As a bonus, the custom serialization is more
efficient, as it skips non-string entries.
As a drive-by, rename LookupStringExists_NoAllocate to
TryStringToIndexOrLookupExisting, to make it clearer that it returns
a non-string for the case when the string is an array index. As another
drive-by, extract StringSet into a separate header.
Bug: v8:10729
Change-Id: I9c990fb2d74d1fe222920408670974a70e969bca
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/2339104
Commit-Queue: Leszek Swirski <leszeks@chromium.org>
Reviewed-by: Jakob Gruber <jgruber@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#69270}
2020-08-06 10:59:55 +00:00
|
|
|
// v8::internal::StringTable::TryStringToIndexOrLookupExisting native function
|
2017-12-12 22:19:44 +00:00
|
|
|
// without producing an EXIT frame.
|
|
|
|
|
v8::HandleScope scope(CcTest::isolate());
|
2019-01-16 17:31:37 +00:00
|
|
|
v8::Local<v8::Context> env = CcTest::NewContext({PROFILER_EXTENSION_ID});
|
2017-12-12 22:19:44 +00:00
|
|
|
v8::Context::Scope context_scope(env);
|
|
|
|
|
|
|
|
|
|
const char* source = R"(
|
|
|
|
|
function jsFunction() {
|
|
|
|
|
var s = {};
|
|
|
|
|
for (var i = 0; i < 1e4; ++i) {
|
|
|
|
|
for (var j = 0; j < 100; j++) {
|
|
|
|
|
s['item' + j] = 'alph';
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
})";
|
|
|
|
|
|
|
|
|
|
CompileRun(source);
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env, "jsFunction");
|
|
|
|
|
|
|
|
|
|
ProfilerHelper helper(env);
|
|
|
|
|
|
2019-05-22 00:06:41 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 100, 0);
|
2017-12-12 22:19:44 +00:00
|
|
|
|
|
|
|
|
// Count the fraction of samples landing in 'jsFunction' (valid stack)
|
|
|
|
|
// vs '(program)' (no stack captured).
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* js_function = FindChild(root, "jsFunction");
|
|
|
|
|
const v8::CpuProfileNode* program = FindChild(root, "(program)");
|
|
|
|
|
if (program) {
|
|
|
|
|
unsigned js_function_samples = TotalHitCount(js_function);
|
|
|
|
|
unsigned program_samples = TotalHitCount(program);
|
|
|
|
|
double valid_samples_ratio =
|
|
|
|
|
1. * js_function_samples / (js_function_samples + program_samples);
|
|
|
|
|
i::PrintF("Ratio: %f\n", valid_samples_ratio);
|
|
|
|
|
// TODO(alph): Investigate other causes of dropped frames. The ratio
|
|
|
|
|
// should be close to 99%.
|
|
|
|
|
CHECK_GE(valid_samples_ratio, 0.3);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
profile->Delete();
|
|
|
|
|
}
|
|
|
|
|
|
2018-04-11 13:09:15 +00:00
|
|
|
TEST(SourcePositionTable) {
|
2018-05-22 09:01:48 +00:00
|
|
|
i::SourcePositionTable info;
|
2018-04-11 13:09:15 +00:00
|
|
|
|
|
|
|
|
// Newly created tables should return NoLineNumberInfo for any lookup.
|
|
|
|
|
int no_info = v8::CpuProfileNode::kNoLineNumberInfo;
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(std::numeric_limits<int>::min()));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(0));
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(0));
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(1));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(9));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(10));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(11));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(19));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(20));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(21));
|
|
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(100));
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(100));
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(no_info, info.GetSourceLineNumber(std::numeric_limits<int>::max()));
|
|
|
|
|
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
info.SetPosition(10, 1, SourcePosition::kNotInlined);
|
|
|
|
|
info.SetPosition(20, 2, SourcePosition::kNotInlined);
|
2018-04-11 13:09:15 +00:00
|
|
|
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
// The only valid return values are 1 or 2 - every pc maps to a line
|
|
|
|
|
// number.
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(std::numeric_limits<int>::min()));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(0));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(1));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(9));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(10));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(11));
|
|
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(19));
|
2019-01-02 12:19:06 +00:00
|
|
|
CHECK_EQ(1, info.GetSourceLineNumber(20));
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(2, info.GetSourceLineNumber(21));
|
|
|
|
|
CHECK_EQ(2, info.GetSourceLineNumber(100));
|
|
|
|
|
CHECK_EQ(2, info.GetSourceLineNumber(std::numeric_limits<int>::max()));
|
2018-04-11 13:09:15 +00:00
|
|
|
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(0));
|
|
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(100));
|
|
|
|
|
|
2018-04-11 13:09:15 +00:00
|
|
|
// Test SetPosition behavior.
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
info.SetPosition(25, 3, 0);
|
2018-05-22 09:01:48 +00:00
|
|
|
CHECK_EQ(2, info.GetSourceLineNumber(21));
|
|
|
|
|
CHECK_EQ(3, info.GetSourceLineNumber(100));
|
|
|
|
|
CHECK_EQ(3, info.GetSourceLineNumber(std::numeric_limits<int>::max()));
|
[cpu-profiler] Reduce the size of inlining information
Previously we stored the source position table, which stored a mapping
of pc offsets to line numbers, and the inline_locations, which stored a
mapping of pc offsets to stacks of {CodeEntry, line_number} pairs. This
was slightly wasteful because we had two different tables which were
both keyed on the pc offset and contained some overlapping information.
This CL combines the two tables in a way. The source position table now
maps a pc offset to a pair of {line_number, inlining_id}. If the
inlining_id is valid, then it can be used to look up the inlining stack
which is stored in inline_locations, but is now keyed by inlining_id
rather than pc offset. This also has the nice effect of de-duplicating
inline stacks which we previously duplicated.
The new structure is similar to how this data is stored by the compiler,
except that we convert 'source positions' (char offset in a file) into
line numbers as we go, because we only care about attributing ticks to
a given line.
Also remove the helper RecordInliningInfo() as this is only actually
used to add inline stacks by one caller (where it is now inlined). The
other callers would always bail out or are only called from
test-cpu-profiler.
Remove AddInlineStack and replace it with SetInlineStacks which adds all
of the stacks at once. We need to do it this way because the source pos
table is passed into the constructor of CodeEntry, so we need to create
it before the CodeEntry, but the inline stacks are not (they are part of
rare_data which is not always present), so we need to add them after
construction. Given that we calculate both the source pos table and the
inline stacks before construction, it's just easier to add them all at
once.
Also add a print() method to CodeEntry to make future debugging easier
as I'm constantly rewriting this locally.
Bug: v8:8575, v8:7719, v8:7203
Change-Id: I39324d6ea13d116d5da5d0a0d243cae76a749c79
Reviewed-on: https://chromium-review.googlesource.com/c/1392195
Commit-Queue: Peter Marshall <petermarshall@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Cr-Commit-Position: refs/heads/master@{#58554}
2019-01-04 11:57:50 +00:00
|
|
|
|
|
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(21));
|
|
|
|
|
CHECK_EQ(0, info.GetInliningId(100));
|
2019-07-29 12:45:30 +00:00
|
|
|
|
|
|
|
|
// Test that subsequent SetPosition calls with the same pc_offset are ignored.
|
|
|
|
|
info.SetPosition(25, 4, SourcePosition::kNotInlined);
|
|
|
|
|
CHECK_EQ(2, info.GetSourceLineNumber(21));
|
|
|
|
|
CHECK_EQ(3, info.GetSourceLineNumber(100));
|
|
|
|
|
CHECK_EQ(3, info.GetSourceLineNumber(std::numeric_limits<int>::max()));
|
|
|
|
|
|
|
|
|
|
CHECK_EQ(SourcePosition::kNotInlined, info.GetInliningId(21));
|
|
|
|
|
CHECK_EQ(0, info.GetInliningId(100));
|
2018-04-11 13:09:15 +00:00
|
|
|
}
|
|
|
|
|
|
2018-04-17 23:29:24 +00:00
|
|
|
TEST(MultipleProfilers) {
|
|
|
|
|
std::unique_ptr<CpuProfiler> profiler1(new CpuProfiler(CcTest::i_isolate()));
|
|
|
|
|
std::unique_ptr<CpuProfiler> profiler2(new CpuProfiler(CcTest::i_isolate()));
|
|
|
|
|
profiler1->StartProfiling("1");
|
|
|
|
|
profiler2->StartProfiling("2");
|
|
|
|
|
profiler1->StopProfiling("1");
|
|
|
|
|
profiler2->StopProfiling("2");
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-08 20:18:29 +00:00
|
|
|
// Tests that logged CodeCreateEvent calls do not crash a reused CpuProfiler.
|
|
|
|
|
// crbug.com/929928
|
|
|
|
|
TEST(CrashReusedProfiler) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
std::unique_ptr<CpuProfiler> profiler(new CpuProfiler(isolate));
|
|
|
|
|
profiler->StartProfiling("1");
|
|
|
|
|
profiler->StopProfiling("1");
|
|
|
|
|
|
|
|
|
|
profiler->StartProfiling("2");
|
|
|
|
|
CreateCode(&env);
|
|
|
|
|
profiler->StopProfiling("2");
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-13 04:34:19 +00:00
|
|
|
// Tests that samples from different profilers on the same isolate do not leak
|
|
|
|
|
// samples to each other. See crbug.com/v8/8835.
|
|
|
|
|
TEST(MultipleProfilersSampleIndependently) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
// Create two profilers- one slow ticking one, and one fast ticking one.
|
|
|
|
|
// Ensure that the slow ticking profiler does not receive samples from the
|
|
|
|
|
// fast ticking one.
|
|
|
|
|
std::unique_ptr<CpuProfiler> slow_profiler(
|
|
|
|
|
new CpuProfiler(CcTest::i_isolate()));
|
|
|
|
|
slow_profiler->set_sampling_interval(base::TimeDelta::FromSeconds(1));
|
2019-05-22 00:06:41 +00:00
|
|
|
slow_profiler->StartProfiling("1", {kLeafNodeLineNumbers});
|
2019-02-13 04:34:19 +00:00
|
|
|
|
|
|
|
|
CompileRun(R"(
|
|
|
|
|
function start() {
|
|
|
|
|
let val = 1;
|
|
|
|
|
for (let i = 0; i < 10e3; i++) {
|
|
|
|
|
val = (val * 2) % 3;
|
|
|
|
|
}
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
)");
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
|
|
|
|
ProfilerHelper helper(env.local());
|
2019-05-22 00:06:41 +00:00
|
|
|
v8::CpuProfile* profile = helper.Run(function, nullptr, 0, 100, 0);
|
2019-02-13 04:34:19 +00:00
|
|
|
|
|
|
|
|
auto slow_profile = slow_profiler->StopProfiling("1");
|
|
|
|
|
CHECK_GT(profile->GetSamplesCount(), slow_profile->samples_count());
|
|
|
|
|
}
|
|
|
|
|
|
2018-10-31 14:29:55 +00:00
|
|
|
void ProfileSomeCode(v8::Isolate* isolate) {
|
|
|
|
|
v8::Isolate::Scope isolate_scope(isolate);
|
|
|
|
|
v8::HandleScope scope(isolate);
|
|
|
|
|
LocalContext context(isolate);
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler* profiler = v8::CpuProfiler::New(isolate);
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::String> profile_name = v8_str("1");
|
|
|
|
|
profiler->StartProfiling(profile_name);
|
|
|
|
|
const char* source = R"(
|
|
|
|
|
function foo() {
|
2018-11-15 12:46:06 +00:00
|
|
|
var x = 0;
|
2018-11-19 16:29:23 +00:00
|
|
|
for (var i = 0; i < 1e3; i++) {
|
2018-11-15 12:46:06 +00:00
|
|
|
for (var j = 0; j < 1e3; j++) {
|
2018-11-19 16:29:23 +00:00
|
|
|
x = i * j;
|
2018-10-31 14:29:55 +00:00
|
|
|
}
|
|
|
|
|
}
|
2018-11-15 12:46:06 +00:00
|
|
|
return x;
|
2018-10-31 14:29:55 +00:00
|
|
|
}
|
|
|
|
|
foo();
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
CompileRun(source);
|
|
|
|
|
profiler->StopProfiling(profile_name);
|
|
|
|
|
profiler->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
class IsolateThread : public v8::base::Thread {
|
|
|
|
|
public:
|
|
|
|
|
IsolateThread() : Thread(Options("IsolateThread")) {}
|
|
|
|
|
|
|
|
|
|
void Run() override {
|
|
|
|
|
v8::Isolate::CreateParams create_params;
|
|
|
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
|
|
|
v8::Isolate* isolate = v8::Isolate::New(create_params);
|
|
|
|
|
ProfileSomeCode(isolate);
|
|
|
|
|
isolate->Dispose();
|
|
|
|
|
}
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
// Checking for crashes and TSAN issues with multiple isolates profiling.
|
|
|
|
|
TEST(MultipleIsolates) {
|
|
|
|
|
IsolateThread thread1;
|
|
|
|
|
IsolateThread thread2;
|
|
|
|
|
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(thread1.Start());
|
|
|
|
|
CHECK(thread2.Start());
|
2018-10-31 14:29:55 +00:00
|
|
|
|
|
|
|
|
thread1.Join();
|
|
|
|
|
thread2.Join();
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-15 19:45:50 +00:00
|
|
|
// Tests that StopProfiling doesn't wait for the next sample tick in order to
|
|
|
|
|
// stop, but rather exits early before a given wait threshold.
|
|
|
|
|
TEST(FastStopProfiling) {
|
|
|
|
|
static const base::TimeDelta kLongInterval = base::TimeDelta::FromSeconds(10);
|
|
|
|
|
static const base::TimeDelta kWaitThreshold = base::TimeDelta::FromSeconds(5);
|
|
|
|
|
|
|
|
|
|
std::unique_ptr<CpuProfiler> profiler(new CpuProfiler(CcTest::i_isolate()));
|
|
|
|
|
profiler->set_sampling_interval(kLongInterval);
|
2019-05-22 00:06:41 +00:00
|
|
|
profiler->StartProfiling("", {kLeafNodeLineNumbers});
|
2019-02-15 19:45:50 +00:00
|
|
|
|
|
|
|
|
v8::Platform* platform = v8::internal::V8::GetCurrentPlatform();
|
|
|
|
|
double start = platform->CurrentClockTimeMillis();
|
|
|
|
|
profiler->StopProfiling("");
|
|
|
|
|
double duration = platform->CurrentClockTimeMillis() - start;
|
|
|
|
|
|
|
|
|
|
CHECK_LT(duration, kWaitThreshold.InMillisecondsF());
|
|
|
|
|
}
|
|
|
|
|
|
2019-03-14 07:25:55 +00:00
|
|
|
TEST(LowPrecisionSamplingStartStopInternal) {
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
CpuProfilesCollection profiles(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator generator(&profiles, code_observer.code_map());
|
2019-03-14 07:25:55 +00:00
|
|
|
std::unique_ptr<ProfilerEventsProcessor> processor(
|
2019-07-18 23:18:18 +00:00
|
|
|
new SamplingEventsProcessor(isolate, &generator, &code_observer,
|
2019-03-14 07:25:55 +00:00
|
|
|
v8::base::TimeDelta::FromMicroseconds(100),
|
|
|
|
|
false));
|
2019-07-29 13:09:02 +00:00
|
|
|
CHECK(processor->Start());
|
2019-03-14 07:25:55 +00:00
|
|
|
processor->StopSynchronously();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(LowPrecisionSamplingStartStopPublic) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
v8::CpuProfiler* cpu_profiler = v8::CpuProfiler::New(env->GetIsolate());
|
|
|
|
|
cpu_profiler->SetUsePreciseSampling(false);
|
|
|
|
|
v8::Local<v8::String> profile_name = v8_str("");
|
|
|
|
|
cpu_profiler->StartProfiling(profile_name, true);
|
|
|
|
|
cpu_profiler->StopProfiling(profile_name);
|
|
|
|
|
cpu_profiler->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2019-04-24 20:21:58 +00:00
|
|
|
const char* naming_test_source = R"(
|
|
|
|
|
(function testAssignmentPropertyNamedFunction() {
|
|
|
|
|
let object = {};
|
|
|
|
|
object.propNamed = function () {
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
};
|
|
|
|
|
object.propNamed();
|
|
|
|
|
})();
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
TEST(StandardNaming) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("CallCollectSample"), func).FromJust();
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler* profiler =
|
|
|
|
|
v8::CpuProfiler::New(env->GetIsolate(), kStandardNaming);
|
|
|
|
|
|
|
|
|
|
const auto profile_name = v8_str("");
|
|
|
|
|
profiler->StartProfiling(profile_name);
|
|
|
|
|
CompileRun(naming_test_source);
|
|
|
|
|
auto* profile = profiler->StopProfiling(profile_name);
|
|
|
|
|
|
|
|
|
|
auto* root = profile->GetTopDownRoot();
|
|
|
|
|
auto* toplevel = FindChild(root, "");
|
|
|
|
|
DCHECK(toplevel);
|
|
|
|
|
|
|
|
|
|
auto* prop_assignment_named_test =
|
|
|
|
|
GetChild(env.local(), toplevel, "testAssignmentPropertyNamedFunction");
|
|
|
|
|
CHECK(FindChild(prop_assignment_named_test, ""));
|
|
|
|
|
|
|
|
|
|
profiler->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
TEST(DebugNaming) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("CallCollectSample"), func).FromJust();
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler* profiler =
|
|
|
|
|
v8::CpuProfiler::New(env->GetIsolate(), kDebugNaming);
|
|
|
|
|
|
|
|
|
|
const auto profile_name = v8_str("");
|
|
|
|
|
profiler->StartProfiling(profile_name);
|
|
|
|
|
CompileRun(naming_test_source);
|
|
|
|
|
auto* profile = profiler->StopProfiling(profile_name);
|
|
|
|
|
|
|
|
|
|
auto* root = profile->GetTopDownRoot();
|
|
|
|
|
auto* toplevel = FindChild(root, "");
|
|
|
|
|
DCHECK(toplevel);
|
|
|
|
|
|
|
|
|
|
auto* prop_assignment_named_test =
|
|
|
|
|
GetChild(env.local(), toplevel, "testAssignmentPropertyNamedFunction");
|
|
|
|
|
CHECK(FindChild(prop_assignment_named_test, "object.propNamed"));
|
|
|
|
|
|
|
|
|
|
profiler->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-08 19:16:42 +00:00
|
|
|
TEST(SampleLimit) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
CompileRun(R"(
|
|
|
|
|
function start() {
|
|
|
|
|
let val = 1;
|
|
|
|
|
for (let i = 0; i < 10e3; i++) {
|
|
|
|
|
val = (val * 2) % 3;
|
|
|
|
|
}
|
|
|
|
|
return val;
|
|
|
|
|
}
|
|
|
|
|
)");
|
|
|
|
|
|
|
|
|
|
// Take 100 samples of `start`, but set the max samples to 50.
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
|
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
v8::CpuProfile* profile =
|
2019-05-22 00:06:41 +00:00
|
|
|
helper.Run(function, nullptr, 0, 100, 0,
|
2019-05-08 19:16:42 +00:00
|
|
|
v8::CpuProfilingMode::kLeafNodeLineNumbers, 50);
|
|
|
|
|
|
|
|
|
|
CHECK_EQ(profile->GetSamplesCount(), 50);
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-14 20:24:49 +00:00
|
|
|
// Tests that a CpuProfile instance subsamples from a stream of tick samples
|
|
|
|
|
// appropriately.
|
|
|
|
|
TEST(ProflilerSubsampling) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
|
|
|
|
ProfilerEventsProcessor* processor =
|
|
|
|
|
new SamplingEventsProcessor(isolate, generator, &code_observer,
|
|
|
|
|
v8::base::TimeDelta::FromMicroseconds(1),
|
|
|
|
|
/* use_precise_sampling */ true);
|
|
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-14 20:24:49 +00:00
|
|
|
|
|
|
|
|
// Create a new CpuProfile that wants samples at 8us.
|
|
|
|
|
CpuProfile profile(&profiler, "",
|
2019-05-22 00:06:41 +00:00
|
|
|
{v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
2019-05-14 20:24:49 +00:00
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 8});
|
|
|
|
|
// Verify that the first sample is always included.
|
|
|
|
|
CHECK(profile.CheckSubsample(base::TimeDelta::FromMicroseconds(10)));
|
|
|
|
|
|
|
|
|
|
// 4 2us samples should result in one 8us sample.
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
|
|
|
|
|
// Profiles should expect the source sample interval to change, in which case
|
|
|
|
|
// they should still take the first sample elapsed after their interval.
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(!profile.CheckSubsample(base::TimeDelta::FromMicroseconds(2)));
|
|
|
|
|
CHECK(profile.CheckSubsample(base::TimeDelta::FromMicroseconds(4)));
|
|
|
|
|
|
|
|
|
|
// Aligned samples (at 8us) are always included.
|
|
|
|
|
CHECK(profile.CheckSubsample(base::TimeDelta::FromMicroseconds(8)));
|
|
|
|
|
|
|
|
|
|
// Samples with a rate of 0 should always be included.
|
|
|
|
|
CHECK(profile.CheckSubsample(base::TimeDelta::FromMicroseconds(0)));
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Tests that the base sampling rate of a CpuProfilesCollection is dynamically
|
|
|
|
|
// chosen based on the GCD of its child profiles.
|
|
|
|
|
TEST(DynamicResampling) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
|
|
|
|
ProfilerEventsProcessor* processor =
|
|
|
|
|
new SamplingEventsProcessor(isolate, generator, &code_observer,
|
|
|
|
|
v8::base::TimeDelta::FromMicroseconds(1),
|
|
|
|
|
/* use_precise_sampling */ true);
|
|
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-14 20:24:49 +00:00
|
|
|
|
|
|
|
|
// Set a 1us base sampling rate, dividing all possible intervals.
|
|
|
|
|
profiler.set_sampling_interval(base::TimeDelta::FromMicroseconds(1));
|
|
|
|
|
|
|
|
|
|
// Verify that the sampling interval with no started profilers is unset.
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(), base::TimeDelta());
|
|
|
|
|
|
|
|
|
|
// Add a 10us profiler, verify that the base sampling interval is as high as
|
|
|
|
|
// possible (10us).
|
|
|
|
|
profiles->StartProfiling("10us",
|
2019-05-22 00:06:41 +00:00
|
|
|
{v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
2019-05-14 20:24:49 +00:00
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 10});
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(10));
|
|
|
|
|
|
|
|
|
|
// Add a 5us profiler, verify that the base sampling interval is as high as
|
|
|
|
|
// possible given a 10us and 5us profiler (5us).
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("5us", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 5});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(5));
|
|
|
|
|
|
|
|
|
|
// Add a 3us profiler, verify that the base sampling interval is 1us (due to
|
|
|
|
|
// coprime intervals).
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("3us", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 3});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(1));
|
|
|
|
|
|
|
|
|
|
// Remove the 5us profiler, verify that the sample interval stays at 1us.
|
|
|
|
|
profiles->StopProfiling("5us");
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(1));
|
|
|
|
|
|
|
|
|
|
// Remove the 10us profiler, verify that the sample interval becomes 3us.
|
|
|
|
|
profiles->StopProfiling("10us");
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(3));
|
|
|
|
|
|
|
|
|
|
// Remove the 3us profiler, verify that the sample interval becomes unset.
|
|
|
|
|
profiles->StopProfiling("3us");
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(), base::TimeDelta());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Ensures that when a non-unit base sampling interval is set on the profiler,
|
|
|
|
|
// that the sampling rate gets snapped to the nearest multiple prior to GCD
|
|
|
|
|
// computation.
|
|
|
|
|
TEST(DynamicResamplingWithBaseInterval) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::Isolate* isolate = CcTest::i_isolate();
|
|
|
|
|
i::HandleScope scope(isolate);
|
|
|
|
|
|
|
|
|
|
CpuProfilesCollection* profiles = new CpuProfilesCollection(isolate);
|
2019-07-18 23:18:18 +00:00
|
|
|
ProfilerCodeObserver code_observer(isolate);
|
|
|
|
|
ProfileGenerator* generator =
|
|
|
|
|
new ProfileGenerator(profiles, code_observer.code_map());
|
|
|
|
|
ProfilerEventsProcessor* processor =
|
|
|
|
|
new SamplingEventsProcessor(isolate, generator, &code_observer,
|
|
|
|
|
v8::base::TimeDelta::FromMicroseconds(1),
|
|
|
|
|
/* use_precise_sampling */ true);
|
|
|
|
|
CpuProfiler profiler(isolate, kDebugNaming, kLazyLogging, profiles, generator,
|
|
|
|
|
processor);
|
2019-05-14 20:24:49 +00:00
|
|
|
|
|
|
|
|
profiler.set_sampling_interval(base::TimeDelta::FromMicroseconds(7));
|
|
|
|
|
|
|
|
|
|
// Verify that the sampling interval with no started profilers is unset.
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(), base::TimeDelta());
|
|
|
|
|
|
|
|
|
|
// Add a profiler with an unset sampling interval, verify that the common
|
|
|
|
|
// sampling interval is equal to the base.
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("unset", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(7));
|
|
|
|
|
profiles->StopProfiling("unset");
|
|
|
|
|
|
|
|
|
|
// Adding a 8us sampling interval rounds to a 14us base interval.
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("8us", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 8});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(14));
|
|
|
|
|
|
|
|
|
|
// Adding a 4us sampling interval should cause a lowering to a 7us interval.
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("4us", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 4});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(7));
|
|
|
|
|
|
|
|
|
|
// Removing the 4us sampling interval should restore the 14us sampling
|
|
|
|
|
// interval.
|
|
|
|
|
profiles->StopProfiling("4us");
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(14));
|
|
|
|
|
|
|
|
|
|
// Removing the 8us sampling interval should unset the common sampling
|
|
|
|
|
// interval.
|
|
|
|
|
profiles->StopProfiling("8us");
|
|
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(), base::TimeDelta());
|
|
|
|
|
|
|
|
|
|
// A sampling interval of 0us should enforce all profiles to have a sampling
|
|
|
|
|
// interval of 0us (the only multiple of 0).
|
|
|
|
|
profiler.set_sampling_interval(base::TimeDelta::FromMicroseconds(0));
|
2019-05-22 00:06:41 +00:00
|
|
|
profiles->StartProfiling("5us", {v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, 5});
|
2019-05-14 20:24:49 +00:00
|
|
|
CHECK_EQ(profiles->GetCommonSamplingInterval(),
|
|
|
|
|
base::TimeDelta::FromMicroseconds(0));
|
|
|
|
|
profiles->StopProfiling("5us");
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-18 23:18:18 +00:00
|
|
|
// Tests that functions compiled after a started profiler is stopped are still
|
|
|
|
|
// visible when the profiler is started again. (https://crbug.com/v8/9151)
|
|
|
|
|
TEST(Bug9151StaleCodeEntries) {
|
|
|
|
|
LocalContext env;
|
|
|
|
|
v8::HandleScope scope(env->GetIsolate());
|
|
|
|
|
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
env->Global()->Set(env.local(), v8_str("CallCollectSample"), func).FromJust();
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler* profiler =
|
|
|
|
|
v8::CpuProfiler::New(env->GetIsolate(), kDebugNaming, kEagerLogging);
|
|
|
|
|
v8::Local<v8::String> profile_name = v8_str("");
|
|
|
|
|
|
|
|
|
|
// Warm up the profiler to create the initial code map.
|
|
|
|
|
profiler->StartProfiling(profile_name);
|
|
|
|
|
profiler->StopProfiling(profile_name);
|
|
|
|
|
|
|
|
|
|
// Log a function compilation (executed once to force a compilation).
|
|
|
|
|
CompileRun(R"(
|
|
|
|
|
function start() {
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
}
|
|
|
|
|
start();
|
|
|
|
|
)");
|
|
|
|
|
|
|
|
|
|
// Restart the profiler, and execute both the JS function and callback.
|
|
|
|
|
profiler->StartProfiling(profile_name, true);
|
|
|
|
|
CompileRun("start();");
|
|
|
|
|
v8::CpuProfile* profile = profiler->StopProfiling(profile_name);
|
|
|
|
|
|
|
|
|
|
auto* root = profile->GetTopDownRoot();
|
|
|
|
|
auto* toplevel = GetChild(env.local(), root, "");
|
|
|
|
|
|
|
|
|
|
auto* start = FindChild(env.local(), toplevel, "start");
|
|
|
|
|
CHECK(start);
|
|
|
|
|
|
|
|
|
|
auto* callback = FindChild(env.local(), start, "CallCollectSample");
|
|
|
|
|
CHECK(callback);
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-19 22:58:21 +00:00
|
|
|
// Tests that functions from other contexts aren't recorded when filtering for
|
|
|
|
|
// another context.
|
|
|
|
|
TEST(ContextIsolation) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
LocalContext execution_env;
|
|
|
|
|
i::HandleScope scope(CcTest::i_isolate());
|
|
|
|
|
|
|
|
|
|
// Install CollectSample callback for more deterministic sampling.
|
|
|
|
|
v8::Local<v8::FunctionTemplate> func_template = v8::FunctionTemplate::New(
|
|
|
|
|
execution_env.local()->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> func =
|
|
|
|
|
func_template->GetFunction(execution_env.local()).ToLocalChecked();
|
|
|
|
|
func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
execution_env->Global()
|
|
|
|
|
->Set(execution_env.local(), v8_str("CallCollectSample"), func)
|
|
|
|
|
.FromJust();
|
|
|
|
|
|
|
|
|
|
ProfilerHelper helper(execution_env.local());
|
|
|
|
|
CompileRun(R"(
|
|
|
|
|
function optimized() {
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function unoptimized() {
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function start() {
|
|
|
|
|
// Test optimized functions
|
|
|
|
|
%PrepareFunctionForOptimization(optimized);
|
|
|
|
|
optimized();
|
|
|
|
|
optimized();
|
|
|
|
|
%OptimizeFunctionOnNextCall(optimized);
|
|
|
|
|
optimized();
|
|
|
|
|
|
|
|
|
|
// Test unoptimized functions
|
|
|
|
|
%NeverOptimizeFunction(unoptimized);
|
|
|
|
|
unoptimized();
|
|
|
|
|
|
|
|
|
|
// Test callback
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
}
|
|
|
|
|
)");
|
|
|
|
|
v8::Local<v8::Function> function =
|
|
|
|
|
GetFunction(execution_env.local(), "start");
|
|
|
|
|
|
|
|
|
|
v8::CpuProfile* same_context_profile = helper.Run(
|
|
|
|
|
function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, execution_env.local());
|
|
|
|
|
const v8::CpuProfileNode* root = same_context_profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* start_node = FindChild(root, "start");
|
|
|
|
|
CHECK(start_node);
|
|
|
|
|
const v8::CpuProfileNode* optimized_node = FindChild(start_node, "optimized");
|
|
|
|
|
CHECK(optimized_node);
|
|
|
|
|
const v8::CpuProfileNode* unoptimized_node =
|
|
|
|
|
FindChild(start_node, "unoptimized");
|
|
|
|
|
CHECK(unoptimized_node);
|
|
|
|
|
const v8::CpuProfileNode* callback_node =
|
|
|
|
|
FindChild(start_node, "CallCollectSample");
|
|
|
|
|
CHECK(callback_node);
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
LocalContext filter_env;
|
|
|
|
|
v8::CpuProfile* diff_context_profile = helper.Run(
|
|
|
|
|
function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, filter_env.local());
|
|
|
|
|
const v8::CpuProfileNode* diff_root =
|
|
|
|
|
diff_context_profile->GetTopDownRoot();
|
|
|
|
|
// Ensure that no children were recorded (including callbacks, builtins).
|
|
|
|
|
CHECK(!FindChild(diff_root, "start"));
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Tests that when a native context that's being filtered is moved, we continue
|
|
|
|
|
// to track its execution.
|
|
|
|
|
TEST(ContextFilterMovedNativeContext) {
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
i::FLAG_manual_evacuation_candidates_selection = true;
|
|
|
|
|
LocalContext env;
|
|
|
|
|
i::HandleScope scope(CcTest::i_isolate());
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
// Install CollectSample callback for more deterministic sampling.
|
|
|
|
|
v8::Local<v8::FunctionTemplate> sample_func_template =
|
|
|
|
|
v8::FunctionTemplate::New(env.local()->GetIsolate(), CallCollectSample);
|
|
|
|
|
v8::Local<v8::Function> sample_func =
|
|
|
|
|
sample_func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
sample_func->SetName(v8_str("CallCollectSample"));
|
|
|
|
|
env->Global()
|
|
|
|
|
->Set(env.local(), v8_str("CallCollectSample"), sample_func)
|
|
|
|
|
.FromJust();
|
|
|
|
|
|
|
|
|
|
// Install a function that triggers the native context to be moved.
|
|
|
|
|
v8::Local<v8::FunctionTemplate> move_func_template =
|
|
|
|
|
v8::FunctionTemplate::New(
|
|
|
|
|
env.local()->GetIsolate(),
|
|
|
|
|
[](const v8::FunctionCallbackInfo<v8::Value>& info) {
|
|
|
|
|
i::Isolate* isolate =
|
|
|
|
|
reinterpret_cast<i::Isolate*>(info.GetIsolate());
|
|
|
|
|
i::heap::ForceEvacuationCandidate(
|
|
|
|
|
i::Page::FromHeapObject(isolate->raw_native_context()));
|
|
|
|
|
CcTest::CollectAllGarbage();
|
|
|
|
|
});
|
|
|
|
|
v8::Local<v8::Function> move_func =
|
|
|
|
|
move_func_template->GetFunction(env.local()).ToLocalChecked();
|
|
|
|
|
move_func->SetName(v8_str("ForceNativeContextMove"));
|
|
|
|
|
env->Global()
|
|
|
|
|
->Set(env.local(), v8_str("ForceNativeContextMove"), move_func)
|
|
|
|
|
.FromJust();
|
|
|
|
|
|
|
|
|
|
ProfilerHelper helper(env.local());
|
|
|
|
|
CompileRun(R"(
|
|
|
|
|
function start() {
|
|
|
|
|
ForceNativeContextMove();
|
|
|
|
|
CallCollectSample();
|
|
|
|
|
}
|
|
|
|
|
)");
|
|
|
|
|
v8::Local<v8::Function> function = GetFunction(env.local(), "start");
|
|
|
|
|
|
|
|
|
|
v8::CpuProfile* profile = helper.Run(
|
|
|
|
|
function, nullptr, 0, 0, 0, v8::CpuProfilingMode::kLeafNodeLineNumbers,
|
|
|
|
|
v8::CpuProfilingOptions::kNoSampleLimit, env.local());
|
|
|
|
|
const v8::CpuProfileNode* root = profile->GetTopDownRoot();
|
|
|
|
|
const v8::CpuProfileNode* start_node = FindChild(root, "start");
|
|
|
|
|
CHECK(start_node);
|
|
|
|
|
|
|
|
|
|
// Verify that after moving the native context, CallCollectSample is still
|
|
|
|
|
// recorded.
|
|
|
|
|
const v8::CpuProfileNode* callback_node =
|
|
|
|
|
FindChild(start_node, "CallCollectSample");
|
|
|
|
|
CHECK(callback_node);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-19 09:24:16 +00:00
|
|
|
enum class EntryCountMode { kAll, kOnlyInlined };
|
|
|
|
|
|
|
|
|
|
// Count the number of unique source positions.
|
|
|
|
|
int GetSourcePositionEntryCount(i::Isolate* isolate, const char* source,
|
|
|
|
|
EntryCountMode mode = EntryCountMode::kAll) {
|
|
|
|
|
std::unordered_set<int64_t> raw_position_set;
|
2018-11-09 10:52:50 +00:00
|
|
|
i::Handle<i::JSFunction> function = i::Handle<i::JSFunction>::cast(
|
|
|
|
|
v8::Utils::OpenHandle(*CompileRun(source)));
|
2020-08-11 09:24:47 +00:00
|
|
|
if (function->ActiveTierIsIgnition()) return -1;
|
2018-11-09 10:52:50 +00:00
|
|
|
i::Handle<i::Code> code(function->code(), isolate);
|
|
|
|
|
i::SourcePositionTableIterator iterator(
|
|
|
|
|
ByteArray::cast(code->source_position_table()));
|
2019-02-19 09:24:16 +00:00
|
|
|
|
2018-11-09 10:52:50 +00:00
|
|
|
while (!iterator.done()) {
|
2019-02-19 09:24:16 +00:00
|
|
|
if (mode == EntryCountMode::kAll ||
|
|
|
|
|
iterator.source_position().isInlined()) {
|
|
|
|
|
raw_position_set.insert(iterator.source_position().raw());
|
|
|
|
|
}
|
2018-11-09 10:52:50 +00:00
|
|
|
iterator.Advance();
|
|
|
|
|
}
|
2019-02-19 09:24:16 +00:00
|
|
|
return static_cast<int>(raw_position_set.size());
|
2018-11-09 10:52:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
UNINITIALIZED_TEST(DetailedSourcePositionAPI) {
|
|
|
|
|
i::FLAG_detailed_line_info = false;
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::Isolate::CreateParams create_params;
|
|
|
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
|
|
|
v8::Isolate* isolate = v8::Isolate::New(create_params);
|
|
|
|
|
|
|
|
|
|
const char* source =
|
|
|
|
|
"function fib(i) {"
|
|
|
|
|
" if (i <= 1) return 1; "
|
|
|
|
|
" return fib(i - 1) +"
|
|
|
|
|
" fib(i - 2);"
|
|
|
|
|
"}"
|
2019-04-30 11:04:41 +00:00
|
|
|
"%PrepareFunctionForOptimization(fib);\n"
|
2018-11-09 10:52:50 +00:00
|
|
|
"fib(5);"
|
|
|
|
|
"%OptimizeFunctionOnNextCall(fib);"
|
|
|
|
|
"fib(5);"
|
|
|
|
|
"fib";
|
|
|
|
|
{
|
|
|
|
|
v8::Isolate::Scope isolate_scope(isolate);
|
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
|
|
|
|
v8::Local<v8::Context> context = v8::Context::New(isolate);
|
|
|
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
|
|
|
|
|
|
|
|
CHECK(!i_isolate->NeedsDetailedOptimizedCodeLineInfo());
|
|
|
|
|
|
|
|
|
|
int non_detailed_positions = GetSourcePositionEntryCount(i_isolate, source);
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);
|
|
|
|
|
CHECK(i_isolate->NeedsDetailedOptimizedCodeLineInfo());
|
|
|
|
|
|
|
|
|
|
int detailed_positions = GetSourcePositionEntryCount(i_isolate, source);
|
|
|
|
|
|
|
|
|
|
CHECK((non_detailed_positions == -1 && detailed_positions == -1) ||
|
|
|
|
|
non_detailed_positions < detailed_positions);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isolate->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-19 09:24:16 +00:00
|
|
|
UNINITIALIZED_TEST(DetailedSourcePositionAPI_Inlining) {
|
|
|
|
|
i::FLAG_detailed_line_info = false;
|
2019-02-20 11:45:50 +00:00
|
|
|
i::FLAG_turbo_inlining = true;
|
2019-02-19 09:24:16 +00:00
|
|
|
i::FLAG_stress_inline = true;
|
|
|
|
|
i::FLAG_always_opt = false;
|
|
|
|
|
i::FLAG_allow_natives_syntax = true;
|
|
|
|
|
v8::Isolate::CreateParams create_params;
|
|
|
|
|
create_params.array_buffer_allocator = CcTest::array_buffer_allocator();
|
|
|
|
|
v8::Isolate* isolate = v8::Isolate::New(create_params);
|
|
|
|
|
|
|
|
|
|
const char* source = R"(
|
|
|
|
|
function foo(x) {
|
|
|
|
|
return bar(x) + 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
function bar(x) {
|
|
|
|
|
var y = 1;
|
|
|
|
|
for (var i = 0; i < x; ++i) {
|
|
|
|
|
y = y * x;
|
|
|
|
|
}
|
|
|
|
|
return x;
|
|
|
|
|
}
|
|
|
|
|
|
2019-05-08 15:54:26 +00:00
|
|
|
%EnsureFeedbackVectorForFunction(bar);
|
2019-04-30 11:04:41 +00:00
|
|
|
%PrepareFunctionForOptimization(foo);
|
2019-02-19 09:24:16 +00:00
|
|
|
foo(5);
|
|
|
|
|
%OptimizeFunctionOnNextCall(foo);
|
|
|
|
|
foo(5);
|
|
|
|
|
foo;
|
|
|
|
|
)";
|
|
|
|
|
|
|
|
|
|
{
|
|
|
|
|
v8::Isolate::Scope isolate_scope(isolate);
|
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
|
|
|
|
v8::Local<v8::Context> context = v8::Context::New(isolate);
|
|
|
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
|
i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate);
|
|
|
|
|
|
|
|
|
|
CHECK(!i_isolate->NeedsDetailedOptimizedCodeLineInfo());
|
|
|
|
|
|
|
|
|
|
int non_detailed_positions =
|
|
|
|
|
GetSourcePositionEntryCount(i_isolate, source, EntryCountMode::kAll);
|
|
|
|
|
int non_detailed_inlined_positions = GetSourcePositionEntryCount(
|
|
|
|
|
i_isolate, source, EntryCountMode::kOnlyInlined);
|
|
|
|
|
|
|
|
|
|
v8::CpuProfiler::UseDetailedSourcePositionsForProfiling(isolate);
|
|
|
|
|
CHECK(i_isolate->NeedsDetailedOptimizedCodeLineInfo());
|
|
|
|
|
|
|
|
|
|
int detailed_positions =
|
|
|
|
|
GetSourcePositionEntryCount(i_isolate, source, EntryCountMode::kAll);
|
|
|
|
|
int detailed_inlined_positions = GetSourcePositionEntryCount(
|
|
|
|
|
i_isolate, source, EntryCountMode::kOnlyInlined);
|
|
|
|
|
|
|
|
|
|
if (non_detailed_positions == -1) {
|
|
|
|
|
CHECK_EQ(non_detailed_positions, detailed_positions);
|
|
|
|
|
} else {
|
|
|
|
|
CHECK_LT(non_detailed_positions, detailed_positions);
|
|
|
|
|
CHECK_LT(non_detailed_inlined_positions, detailed_inlined_positions);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
isolate->Dispose();
|
|
|
|
|
}
|
|
|
|
|
|
2017-09-30 13:19:52 +00:00
|
|
|
} // namespace test_cpu_profiler
|
|
|
|
|
} // namespace internal
|
|
|
|
|
} // namespace v8
|
