59#if !defined(DART_PRECOMPILED_RUNTIME)
74#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
82 FLAG_background_compilation =
false;
83 FLAG_concurrent_mark =
false;
84 FLAG_concurrent_sweep =
false;
85 FLAG_scavenger_tasks = 0;
86 FLAG_old_gen_growth_time_ratio = 0;
87 FLAG_random_seed = 0x44617274;
93 "Enable deterministic mode.");
96 disable_thread_pool_limit,
98 "Disables the limit of the thread pool (simulates custom embedder "
99 "with custom message handler on unlimited number of threads).");
104#define IG (isolate_group())
109class VerifyOriginId :
public IsolateVisitor {
111 explicit VerifyOriginId(
Dart_Port id) : id_(
id) {}
113 void VisitIsolate(Isolate* isolate) {
ASSERT(isolate->origin_id() != id_); }
137 bool saved_external_typed_data =
false;
146 intptr_t next_entry_index = 0;
147 for (intptr_t i = 0; i < loaded_blobs.
Length(); i++) {
148 weak_property ^= loaded_blobs.
At(i);
150 if (i != next_entry_index) {
152 weak_property_tmp ^= loaded_blobs.
At(next_entry_index);
153 weak_property_tmp.
set_key(existing_entry);
158 if (next_entry_index < loaded_blobs.
Length()) {
160 weak_property ^= loaded_blobs.
At(next_entry_index);
161 weak_property.
set_key(external_typed_data);
163 saved_external_typed_data =
true;
165 if (next_entry_index < loaded_blobs.
Length()) {
168 while (next_entry_index < loaded_blobs.
Length()) {
170 weak_property ^= loaded_blobs.
At(next_entry_index);
171 weak_property.
set_key(nullExternalTypedData);
176 if (!saved_external_typed_data) {
179 weak_property.
set_key(external_typed_data);
192 ASSERT(heap_ ==
nullptr && heap !=
nullptr);
198 return idle_start_time_ > 0 && FLAG_idle_timeout_micros != 0 &&
199 disabled_counter_ == 0;
204 if (disabled_counter_ == 0) {
213 if (idle_start_time_ > 0 && disabled_counter_ == 0) {
214 const int64_t expiry_time = idle_start_time_ + FLAG_idle_timeout_micros;
215 if (expiry_time < now) {
216 idle_start_time_ = 0;
221 *expiry = now + FLAG_idle_timeout_micros;
230 if (heap_ !=
nullptr) {
236 idle_start_time_ = 0;
246 : handler_(handler) {
247 if (handler_ !=
nullptr) {
249 ++handler_->disabled_counter_;
250 handler_->idle_start_time_ = 0;
255 if (handler_ !=
nullptr) {
257 --handler_->disabled_counter_;
258 ASSERT(handler_->disabled_counter_ >= 0);
279 if (FLAG_idle_timeout_micros == 0)
return;
285 int64_t idle_expiry = 0;
320void MutatorThreadPool::NotifyIdle() {
330 : class_table_(nullptr),
331 cached_class_table_table_(nullptr),
332 object_store_(object_store),
333 class_table_allocator_(),
334 is_vm_isolate_(is_vm_isolate),
335 embedder_data_(embedder_data),
339 start_time_micros_(
OS::GetCurrentMonotonicMicros()),
340 is_system_isolate_group_(
source->
flags.is_system_isolate),
342#
if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
343 last_reload_timestamp_(
OS::GetCurrentTimeMillis()),
344 reload_every_n_stack_overflow_checks_(FLAG_reload_every),
352 saved_unlinked_calls_(
Array::null()),
353 initial_field_table_(new
FieldTable(nullptr)),
354#
if !defined(DART_PRECOMPILED_RUNTIME)
358 type_canonicalization_mutex_(
361 "IsolateGroup::type_arguments_canonicalization_mutex_")),
362 subtype_test_cache_mutex_(
364 megamorphic_table_mutex_(
366 type_feedback_mutex_(
368 patchable_call_mutex_(
370 constant_canonicalization_mutex_(
371 NOT_IN_PRODUCT(
"IsolateGroup::constant_canonicalization_mutex_")),
372 kernel_data_lib_cache_mutex_(
374 kernel_data_class_cache_mutex_(
376 kernel_constants_mutex_(
381 active_mutators_monitor_(new
Monitor()),
382 max_active_mutators_(
Scavenger::MaxMutatorThreadCount())
401 id_ = isolate_group_random_->
NextJSInt();
403 heap_walk_class_table_ = class_table_ =
405 cached_class_table_table_.
store(class_table_->table());
425 ASSERT(marking_stack_ ==
nullptr);
427 if (obfuscation_map_ !=
nullptr) {
428 for (intptr_t i = 0; obfuscation_map_[i] !=
nullptr; i++) {
429 delete[] obfuscation_map_[i];
431 delete[] obfuscation_map_;
434 class_table_allocator_.
Free(class_table_);
435 if (heap_walk_class_table_ != class_table_) {
436 class_table_allocator_.
Free(heap_walk_class_table_);
447 ASSERT(isolates_lock_->IsCurrentThreadWriter());
448 isolates_.Append(isolate);
457 return isolate_count_ == 0 || isolate_count_ == 1;
467 isolates_.Remove(isolate);
473 return isolate_count_ == 0;
477 bool is_service_or_kernel_isolate) {
481 : FLAG_new_gen_semi_max_size *
MBInWords,
483 : FLAG_old_gen_heap_size) *
486#define ISOLATE_GROUP_METRIC_CONSTRUCTORS(type, variable, name, unit) \
487 metric_##variable##_.InitInstance(this, name, nullptr, Metric::unit);
489#undef ISOLATE_GROUP_METRIC_CONSTRUCTORS
493 char*
name =
nullptr;
499 const bool trace_shutdown = FLAG_trace_shutdown;
501 if (trace_shutdown) {
510 if (!is_vm_isolate_) {
511 ASSERT(thread_pool_ !=
nullptr);
512 thread_pool_->Shutdown();
513 thread_pool_.reset();
522 if (heap_ !=
nullptr) {
525 PageSpace* old_space = heap_->old_space();
527 while (old_space->
tasks() > 0) {
538 if (initial_spawn_successful_ && !is_vm_isolate_) {
540 if (group_shutdown_callback !=
nullptr) {
550 if (trace_shutdown) {
552 "ms] SHUTDOWN: Notifying "
553 "isolate group shutdown (%s)\n",
557 if (!Isolate::creation_enabled_ &&
561 if (trace_shutdown) {
563 "ms] SHUTDOWN: Done Notifying "
564 "isolate group shutdown (%s)\n",
568 if (trace_shutdown) {
575void IsolateGroup::set_heap(std::unique_ptr<Heap> heap) {
577 heap_ = std::move(
heap);
585 bool is_nested_reenter) {
590 if (is_nested_reenter) {
602 ASSERT(active_mutators_ <= max_active_mutators_);
603 while (active_mutators_ == max_active_mutators_) {
618 if (is_nested_exit) {
628 ASSERT(active_mutators_ <= max_active_mutators_);
630 if (waiting_mutators_ > 0) {
643 jsobj->
AddProperty(
"type", (ref ?
"@IsolateGroup" :
"IsolateGroup"));
654 JSONArray isolate_array(jsobj,
"isolates");
655 for (
auto it = isolates_.Begin(); it != isolates_.End(); ++it) {
657 isolate_array.
AddValue(isolate,
true);
679 for (
auto isolate_group : *isolate_groups_) {
687 std::function<
void()> not_found) {
689 for (
auto isolate_group : *isolate_groups_) {
690 if (isolate_group->id() ==
id) {
700 isolate_groups_->Append(isolate_group);
705 isolate_groups_->Remove(isolate_group);
710 for (
auto group : *isolate_groups_) {
720 for (
auto group : *isolate_groups_) {
721 if (!group->is_vm_isolate()) {
729 ASSERT(isolate_groups_rwlock_ ==
nullptr);
730 isolate_groups_rwlock_ =
new RwLock();
731 ASSERT(isolate_groups_ ==
nullptr);
733 isolate_group_random_ =
new Random();
737 delete isolate_group_random_;
738 isolate_group_random_ =
nullptr;
739 delete isolate_groups_rwlock_;
740 isolate_groups_rwlock_ =
nullptr;
741 ASSERT(isolate_groups_->IsEmpty());
742 delete isolate_groups_;
743 isolate_groups_ =
nullptr;
751 if (handle_ ==
nullptr) {
760 state->FreePersistentHandle(handle_);
764#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
778void IsolateGroup::ValidateClassTable() {
784 const Object& initial_value) {
788 const bool need_to_grow_backing_store =
790 const intptr_t field_id = field.
field_id();
794 if (need_to_grow_backing_store) {
798 for (
auto isolate : isolates_) {
799 auto field_table = isolate->field_table();
800 if (field_table->IsReadyToUse()) {
801 field_table->Register(field, field_id);
802 field_table->SetAt(field_id, initial_value.
ptr());
806 for (
auto isolate : isolates_) {
807 auto field_table = isolate->field_table();
808 if (field_table->IsReadyToUse()) {
809 field_table->Register(field, field_id);
810 field_table->SetAt(field_id, initial_value.
ptr());
817#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
822 const intptr_t field_id = field.
field_id();
829 if (field_table->IsReadyToUse()) {
830 field_table->Free(field_id);
838 Isolate*
const isolate = Isolate::InitIsolate(
"temp",
this,
flags);
839 ASSERT(isolate !=
nullptr);
846 ASSERT(thread !=
nullptr);
864 for (intptr_t i = 0; i < num_cids; i++) {
865 old_constant_tables[i] =
nullptr;
869 for (intptr_t
cid = kInstanceCid;
cid < num_cids;
cid++) {
879 if ((
cid == kMintCid) || (
cid == kDoubleCid)) {
903 for (intptr_t
cid = kInstanceCid;
cid < num_cids;
cid++) {
904 Array* old_constants = old_constant_tables[
cid];
905 if (old_constants ==
nullptr)
continue;
909 CanonicalInstancesSet::Iterator it(&set);
910 while (it.MoveNext()) {
911 constant ^= set.GetKey(it.Current());
920 for (intptr_t
cid = kInstanceCid;
cid < num_cids;
cid++) {
921 Array* old_constants = old_constant_tables[
cid];
922 if (old_constants ==
nullptr)
continue;
926 CanonicalInstancesSet::Iterator it(&set);
951 while (it.MoveNext()) {
952 old_value ^= set.GetKey(it.Current());
955 for (intptr_t j = 0; j < new_values.
Length(); j++) {
956 new_value ^= new_values.
At(j);
964 new_value = deleted.
ptr();
967 if (old_value.
ptr() != new_value.
ptr()) {
975 while (it.MoveNext()) {
976 old_value ^= set.GetKey(it.Current());
984 if (old_value.
ptr() != new_value.
ptr()) {
1004 uint64_t capability) {
1018 &array_entry_msg_kind,
1019 &array_entry_msg_id,
1020 &array_entry_capability,
1025 message.value.as_array.values = array_entries;
1045 const char*
name()
const;
1055 void CheckAccess()
const;
1079 : isolate_(isolate) {}
1084 return isolate_->
name();
1090ErrorPtr IsolateMessageHandler::HandleLibMessage(
const Array&
message) {
1092 Zone* zone =
T->zone();
1095 const intptr_t msg_type = Smi::Cast(
type).Value();
1101 if (!
I->VerifyPauseCapability(obj))
return Error::null();
1104 if (
I->AddResumeCapability(Capability::Cast(obj))) {
1113 if (!
I->VerifyPauseCapability(obj))
return Error::null();
1116 if (
I->RemoveResumeCapability(Capability::Cast(obj))) {
1126 const SendPort& send_port = SendPort::Cast(obj2);
1129 const intptr_t priority = Smi::Cast(obj3).Value();
1131 if (!obj4.IsInstance() && !obj4.IsNull())
return Error::null();
1132 const Instance& response =
1133 obj4.IsNull() ? Instance::null_instance() : Instance::Cast(obj4);
1157 const intptr_t priority = Smi::Cast(obj).Value();
1161 if (
I->VerifyTerminateCapability(obj)) {
1165 String::New(
"isolate terminated by Isolate.kill"));
1166 const UnwindError&
error =
1168 error.set_is_user_initiated(
true);
1199 if (!
I->VerifyPauseCapability(obj))
return Error::null();
1201#if !defined(PRODUCT)
1203 if (
I->debugger()->PauseEvent() ==
nullptr) {
1204 return I->debugger()->PauseInterrupted();
1213 const intptr_t priority = Smi::Cast(obj).Value();
1215 return I->InvokePendingServiceExtensionCalls();
1243 const SendPort& listener = SendPort::Cast(obj);
1249 if (!response.IsInstance() && !response.IsNull()) {
1252 I->AddExitListener(listener, response.IsNull()
1253 ? Instance::null_instance()
1254 : Instance::Cast(response));
1259 I->RemoveExitListener(listener);
1263 I->AddErrorListener(listener);
1267 I->RemoveErrorListener(listener);
1279 if (!
I->VerifyTerminateCapability(obj))
return Error::null();
1283 I->SetErrorsFatal(Bool::Cast(obj).
value());
1288#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
1291 T->CheckForSafepoint();
1301 FATAL(
"Unknown OOB message type: %" Pd "\n", msg_type);
1325 std::unique_ptr<Message>
message) {
1331#if defined(SUPPORT_TIMELINE)
1332 TimelineBeginEndScope tbes(
1333 thread, Timeline::GetIsolateStream(),
1334 message->IsOOB() ?
"HandleOOBMessage" :
"HandleMessage");
1335 tbes.SetNumArguments(1);
1336 tbes.CopyArgument(0,
"isolateName",
I->name());
1341 if (msg_obj.IsError()) {
1343 return ProcessUnhandledException(Error::Cast(msg_obj));
1345 if (!msg_obj.
IsNull() && !msg_obj.IsInstance()) {
1354 msg ^= msg_obj.
ptr();
1361 if (msg.IsArray()) {
1362 const Array& oob_msg = Array::Cast(msg);
1363 if (oob_msg.
Length() > 0) {
1365 if (oob_tag.IsSmi()) {
1366 switch (Smi::Cast(oob_tag).
Value()) {
1371 if (!
error.IsNull()) {
1372 status = ProcessUnhandledException(
error);
1381 if (!
error.IsNull()) {
1382 status = ProcessUnhandledException(
error);
1397 }
else if (
message->IsFinalizerInvocationRequest()) {
1401 if (msg_handler.IsError()) {
1402 status = ProcessUnhandledException(Error::Cast(msg_handler));
1410 if (msg.IsArray()) {
1411 const Array& msg_arr = Array::Cast(msg);
1412 if (msg_arr.
Length() > 0) {
1414 if (oob_tag.IsSmi() &&
1417 if (!
error.IsNull()) {
1418 status = ProcessUnhandledException(
error);
1426 if (msg_handler.IsError()) {
1427 status = ProcessUnhandledException(Error::Cast(msg_handler));
1428 }
else if (msg_handler.
IsNull()) {
1449 }
else if (FLAG_trace_service) {
1450 OS::PrintErr(
"vm-service: Dropping event of type PauseStart (%s)\n",
1465 }
else if (FLAG_trace_service) {
1466 OS::PrintErr(
"vm-service: Dropping event of type PauseExit (%s)\n",
1473void IsolateMessageHandler::CheckAccess()
const {
1485 if (
error.IsUnwindError()) {
1496 if (FLAG_trace_isolates) {
1498 "[!] Unhandled exception in %s:\n"
1500 T->isolate()->name(),
result.ToErrorCString());
1503 NoReloadScope no_reload(
T);
1505 const char* exception_cstr =
nullptr;
1506 const char* stacktrace_cstr =
nullptr;
1507 if (
result.IsUnhandledException()) {
1508 Zone* zone =
T->zone();
1509 const UnhandledException& uhe = UnhandledException::Cast(
result);
1511 if (exception.ptr() ==
IG->object_store()->out_of_memory()) {
1512 exception_cstr =
"Out of Memory";
1513 }
else if (exception.ptr() ==
IG->object_store()->stack_overflow()) {
1514 exception_cstr =
"Stack Overflow";
1516 const Object& exception_str =
1518 if (!exception_str.IsString()) {
1519 exception_cstr = exception.ToCString();
1521 exception_cstr = exception_str.ToCString();
1526 stacktrace_cstr = stacktrace.ToCString();
1528 exception_cstr =
result.ToErrorCString();
1530 if (
result.IsUnwindError()) {
1536 I->NotifyErrorListeners(exception_cstr, stacktrace_cstr);
1537 if (
I->ErrorsFatal()) {
1539 T->ClearStickyError();
1543#if !defined(PRODUCT)
1548 if (
result.IsUnhandledException()) {
1549 const UnhandledException&
error = UnhandledException::Cast(
result);
1550 InstancePtr exception =
error.exception();
1551 if ((exception ==
IG->object_store()->out_of_memory()) ||
1552 (exception ==
IG->object_store()->stack_overflow())) {
1566#define INIT_FROM_FLAG(when, name, bitname, isolate_flag, flag) \
1567 api_flags->isolate_flag = flag;
1569#undef INIT_FROM_FLAG
1577#define INIT_FROM_FIELD(when, name, bitname, isolate_flag, flag) \
1578 api_flags->isolate_flag = name();
1580#undef INIT_FROM_FIELD
1587#if defined(DART_PRECOMPILER)
1588#define FLAG_FOR_PRECOMPILER(action) action
1590#define FLAG_FOR_PRECOMPILER(action)
1593#if !defined(PRODUCT)
1594#define FLAG_FOR_NONPRODUCT(action) action
1596#define FLAG_FOR_NONPRODUCT(action)
1599#define FLAG_FOR_PRODUCT(action) action
1601#define SET_FROM_FLAG(when, name, bitname, isolate_flag, flag) \
1602 FLAG_FOR_##when(isolate_group_flags_ = bitname##Bit::update( \
1603 api_flags.isolate_flag, isolate_group_flags_));
1606#undef FLAG_FOR_NONPRODUCT
1607#undef FLAG_FOR_PRECOMPILER
1608#undef FLAG_FOR_PRODUCT
1616#define INIT_FROM_FLAG(when, name, bitname, isolate_flag, flag) \
1617 api_flags->isolate_flag = flag;
1619#undef INIT_FROM_FLAG
1629#define INIT_FROM_FIELD(when, name, bitname, isolate_flag, flag) \
1630 api_flags->isolate_flag = name();
1632#undef INIT_FROM_FIELD
1639#if defined(DART_PRECOMPILER)
1640#define FLAG_FOR_PRECOMPILER(action) action
1642#define FLAG_FOR_PRECOMPILER(action)
1645#if !defined(PRODUCT)
1646#define FLAG_FOR_NONPRODUCT(action) action
1648#define FLAG_FOR_NONPRODUCT(action)
1651#define FLAG_FOR_PRODUCT(action) action
1653#define SET_FROM_FLAG(when, name, bitname, isolate_flag, flag) \
1654 FLAG_FOR_##when(isolate_flags_ = bitname##Bit::update( \
1655 api_flags.isolate_flag, isolate_flags_));
1658#undef FLAG_FOR_NONPRODUCT
1659#undef FLAG_FOR_PRECOMPILER
1660#undef FLAG_FOR_PRODUCT
1666void BaseIsolate::AssertCurrent(
BaseIsolate* isolate) {
1672#define REUSABLE_HANDLE_SCOPE_INIT(object) \
1673 reusable_##object##_handle_scope_active_(false),
1675#define REUSABLE_HANDLE_SCOPE_INIT(object)
1678#define REUSABLE_HANDLE_INITIALIZERS(object) object##_handle_(nullptr),
1683 static const char*
Name() {
return "LibraryPrefixMapTraits"; }
1686 if (!
a.IsLibraryPrefix() || !
b.IsLibraryPrefix()) {
1689 return a.ptr() ==
b.ptr();
1693 auto& prefix = LibraryPrefix::Cast(obj);
1700Isolate::Isolate(IsolateGroup* isolate_group,
1703 current_tag_(UserTag::null()),
1704 default_tag_(UserTag::null()),
1705 field_table_(new FieldTable(this)),
1706 finalizers_(GrowableObjectArray::null()),
1707 isolate_group_(isolate_group),
1708 isolate_object_store_(new IsolateObjectStore()),
1710#
if !defined(PRODUCT)
1711 last_resume_timestamp_(OS::GetCurrentTimeMillis()),
1713 pending_service_extension_calls_(GrowableObjectArray::null()),
1714 registered_service_extension_handlers_(GrowableObjectArray::null()),
1716 metric_##variable##_(),
1720 start_time_micros_(OS::GetCurrentMonotonicMicros()),
1721 message_notify_callback_(nullptr),
1722 on_shutdown_callback_(Isolate::ShutdownCallback()),
1723 on_cleanup_callback_(Isolate::CleanupCallback()),
1726 tag_table_(GrowableObjectArray::null()),
1727 sticky_error_(Error::null()),
1728 spawn_count_monitor_(),
1729 handler_info_cache_(),
1730 catch_entry_moves_cache_(),
1731 wake_pause_event_handler_count_(0),
1732 loaded_prefixes_set_storage_(nullptr) {
1733 FlagsCopyFrom(api_flags);
1734 SetErrorsFatal(
true);
1741#undef REUSABLE_HANDLE_SCOPE_INIT
1742#undef REUSABLE_HANDLE_INITIALIZERS
1745#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
1750#if !defined(PRODUCT)
1752 debugger_ =
nullptr;
1753 delete object_id_ring_;
1754 object_id_ring_ =
nullptr;
1755 delete pause_loop_monitor_;
1756 pause_loop_monitor_ =
nullptr;
1760 delete field_table_;
1761#if defined(USING_SIMULATOR)
1764 delete message_handler_;
1769 ASSERT(spawn_count_ == 0);
1777void Isolate::InitVM() {
1778 create_group_callback_ =
nullptr;
1779 initialize_callback_ =
nullptr;
1780 shutdown_callback_ =
nullptr;
1781 cleanup_callback_ =
nullptr;
1782 cleanup_group_callback_ =
nullptr;
1783 register_kernel_blob_callback_ =
nullptr;
1784 unregister_kernel_blob_callback_ =
nullptr;
1785 if (isolate_creation_monitor_ ==
nullptr) {
1786 isolate_creation_monitor_ =
new Monitor();
1788 ASSERT(isolate_creation_monitor_ !=
nullptr);
1792Isolate* Isolate::InitIsolate(
const char* name_prefix,
1793 IsolateGroup* isolate_group,
1795 bool is_vm_isolate) {
1796 Isolate*
result =
new Isolate(isolate_group, api_flags);
1798 result->BuildName(name_prefix);
1806 result->isolate_object_store()->Init();
1811#if !defined(PRODUCT)
1813#define ISOLATE_METRIC_INIT(type, variable, name, unit) \
1814 result->metric_##variable##_.InitInstance(result, name, nullptr, \
1817#undef ISOLATE_METRIC_INIT
1829 result->message_handler_ =
new IsolateMessageHandler(
result);
1834 VerifyOriginId id_verifier(
result->main_port());
1843 result->set_pause_capability(
result->random()->NextJSInt());
1844 result->set_terminate_capability(
result->random()->NextJSInt());
1846#if !defined(PRODUCT)
1853 isolate_group->RegisterIsolate(
result);
1858#if !defined(DART_PRECOMPILED_RUNTIME)
1865 if (FLAG_trace_isolates) {
1866 if (name_prefix ==
nullptr || strcmp(name_prefix,
"vm-isolate") != 0) {
1868 "[+] Starting isolate:\n"
1875 if (!TryMarkIsolateReady(
result)) {
1876 result->LowLevelShutdown();
1877 Isolate::LowLevelCleanup(
result);
1918 bool is_executable) {
1926 for (
Isolate* isolate : isolates_) {
1927 isolate->ScheduleInterrupts(interrupt_bits);
1936 if (mthread !=
nullptr) {
1961 ASSERT((
id == main_port_ && origin_id_ == 0) || (origin_id_ == main_port_));
1966 finalizers_ =
value.ptr();
1973 return (debugger_ !=
nullptr) && (debugger_->
PauseEvent() !=
nullptr);
1978#if !defined(PRODUCT)
1979 if (debugger_ ==
nullptr) {
1984 if (!
error.IsNull()) {
1996void Isolate::BuildName(
const char* name_prefix) {
1997 ASSERT(name_ ==
nullptr);
1998 if (name_prefix ==
nullptr) {
2005#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
2029 if (thread->no_reload_scope_depth_ != 0) {
2039 const char* root_script_url,
2040 const char* packages_url,
2041 bool dont_delete_reload_context) {
2049 std::shared_ptr<IsolateGroupReloadContext> group_reload_context(
2051 group_reload_context_ = group_reload_context;
2054 program_reload_context_ =
2056 const bool success =
2057 group_reload_context_->Reload(force_reload, root_script_url, packages_url,
2060 if (!dont_delete_reload_context) {
2068 const uint8_t* kernel_buffer,
2069 intptr_t kernel_buffer_size,
2070 bool dont_delete_reload_context) {
2078 std::shared_ptr<IsolateGroupReloadContext> group_reload_context(
2080 group_reload_context_ = group_reload_context;
2083 program_reload_context_ =
2085 const bool success = group_reload_context_->Reload(
2088 nullptr, kernel_buffer, kernel_buffer_size);
2089 if (!dont_delete_reload_context) {
2097 group_reload_context_.reset();
2099 delete program_reload_context_;
2100 program_reload_context_ =
nullptr;
2108 return "Isolate is already runnable";
2111 return "The embedder has to ensure there is a root library (e.g. by "
2112 "calling Dart_LoadScriptFromKernel ).";
2128 if (FLAG_pause_isolates_on_unhandled_exceptions) {
2133#if defined(SUPPORT_TIMELINE)
2135 ASSERT(stream !=
nullptr);
2136 TimelineEvent*
event = stream->StartEvent();
2137 if (
event !=
nullptr) {
2138 event->Instant(
"Runnable");
2152 return !capability.
IsNull() && capability.IsCapability() &&
2157 return !capability.
IsNull() && capability.IsCapability() &&
2163 const intptr_t kMaxResumeCapabilities =
2164 compiler::target::kSmiMax / (6 *
kWordSize);
2169 intptr_t insertion_index = -1;
2170 for (intptr_t i = 0; i < caps.
Length(); i++) {
2171 current ^= caps.
At(i);
2173 if (insertion_index < 0) {
2174 insertion_index = i;
2176 }
else if (current.
Id() == capability.
Id()) {
2180 if (insertion_index < 0) {
2181 if (caps.
Length() >= kMaxResumeCapabilities) {
2187 caps.
Add(capability);
2189 caps.
SetAt(insertion_index, capability);
2198 for (intptr_t i = 0; i < caps.
Length(); i++) {
2199 current ^= caps.
At(i);
2200 if (!current.
IsNull() && (current.
Id() == capability.
Id())) {
2203 caps.
SetAt(i, current);
2215 const intptr_t kMaxListeners = compiler::target::kSmiMax / (12 *
kWordSize);
2220 intptr_t insertion_index = -1;
2221 for (intptr_t i = 0; i < listeners.
Length(); i += 2) {
2222 current ^= listeners.
At(i);
2224 if (insertion_index < 0) {
2225 insertion_index = i;
2227 }
else if (current.
Id() == listener.
Id()) {
2228 listeners.
SetAt(i + 1, response);
2232 if (insertion_index < 0) {
2233 if (listeners.
Length() >= kMaxListeners) {
2239 listeners.
Add(listener);
2240 listeners.
Add(response);
2242 listeners.
SetAt(insertion_index, listener);
2243 listeners.
SetAt(insertion_index + 1, response);
2251 for (intptr_t i = 0; i < listeners.
Length(); i += 2) {
2252 current ^= listeners.
At(i);
2253 if (!current.
IsNull() && (current.
Id() == listener.
Id())) {
2256 listeners.
SetAt(i, current);
2257 listeners.
SetAt(i + 1, Object::null_instance());
2266 if (listeners.
IsNull())
return;
2270 for (intptr_t i = 0; i < listeners.
Length(); i += 2) {
2271 listener ^= listeners.
At(i);
2272 if (!listener.
IsNull()) {
2274 response ^= listeners.
At(i + 1);
2282 const intptr_t kMaxListeners = compiler::target::kSmiMax / (6 *
kWordSize);
2287 intptr_t insertion_index = -1;
2288 for (intptr_t i = 0; i < listeners.
Length(); i++) {
2289 current ^= listeners.
At(i);
2291 if (insertion_index < 0) {
2292 insertion_index = i;
2294 }
else if (current.
Id() == listener.
Id()) {
2298 if (insertion_index < 0) {
2299 if (listeners.
Length() >= kMaxListeners) {
2305 listeners.
Add(listener);
2307 listeners.
SetAt(insertion_index, listener);
2315 for (intptr_t i = 0; i < listeners.
Length(); i++) {
2316 current ^= listeners.
At(i);
2317 if (!current.
IsNull() && (current.
Id() == listener.
Id())) {
2320 listeners.
SetAt(i, current);
2327 const char* stacktrace) {
2330 if (listeners.
IsNull())
return false;
2340 arr_values[0] = &msg;
2342 if (stacktrace ==
nullptr) {
2348 arr_values[1] = &stack;
2351 bool was_somebody_notified =
false;
2352 for (intptr_t i = 0; i < listeners.
Length(); i++) {
2353 listener ^= listeners.
At(i);
2354 if (!listener.
IsNull()) {
2357 was_somebody_notified =
true;
2360 return was_somebody_notified;
2377 reinterpret_cast<uword>(
this));
2381 return message_handler_;
2384void Isolate::RunAndCleanupFinalizersOnShutdown() {
2395 const auto& finalizers =
2397 if (!finalizers.IsNull()) {
2398 const intptr_t num_finalizers = finalizers.Length();
2402 auto& all_entries =
Set::Handle(stack_zone.GetZone());
2403 for (
int i = 0; i < num_finalizers; i++) {
2404 weak_reference ^= finalizers.At(i);
2405 finalizer ^= weak_reference.target();
2406 if (!finalizer.IsNull()) {
2407 if (finalizer.isolate() ==
this) {
2408 if (FLAG_trace_finalizers) {
2409 THR_Print(
"Isolate %p Setting finalizer %p isolate to null\n",
this,
2410 finalizer.ptr()->untag());
2413 finalizer.set_isolate(
nullptr);
2419 if (finalizer.IsNativeFinalizer()) {
2421 const auto& native_finalizer = NativeFinalizer::Cast(finalizer);
2422 all_entries = finalizer.all_entries();
2423 Set::Iterator iterator(all_entries);
2424 while (iterator.MoveNext()) {
2425 current_entry ^= iterator.CurrentKey();
2426 native_finalizer.RunCallback(current_entry,
"Isolate shutdown");
2434void Isolate::LowLevelShutdown() {
2438 StackZone stack_zone(thread);
2439 HandleScope handle_scope(thread);
2440 NoSafepointScope no_safepoint_scope;
2443 if (
group()->object_store() !=
nullptr) {
2445 if (
error.IsNull() || !
error.IsUnwindError() ||
2446 UnwindError::Cast(
error).is_user_initiated()) {
2455 delete message_handler_;
2456 message_handler_ =
nullptr;
2460 if (ffi_callback_list_head_ !=
nullptr) {
2462 &ffi_callback_list_head_);
2465#if !defined(PRODUCT)
2466 if (FLAG_dump_megamorphic_stats) {
2469 if (FLAG_dump_symbol_stats) {
2472 if (FLAG_trace_isolates) {
2475 "[-] Stopping isolate:\n"
2479 if (FLAG_print_metrics) {
2482#define ISOLATE_GROUP_METRIC_PRINT(type, variable, name, unit) \
2483 OS::PrintErr("%s\n", isolate_group_->Get##variable##Metric()->ToString());
2485#undef ISOLATE_GROUP_METRIC_PRINT
2486#define ISOLATE_METRIC_PRINT(type, variable, name, unit) \
2487 OS::PrintErr("%s\n", metric_##variable##_.ToString());
2489#undef ISOLATE_METRIC_PRINT
2495#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
2497 if (FLAG_reload_every_back_off) {
2498 if (reload_every_n_stack_overflow_checks_ < 5000) {
2499 reload_every_n_stack_overflow_checks_ += 99;
2501 const auto old_value = reload_every_n_stack_overflow_checks_;
2502 reload_every_n_stack_overflow_checks_ = old_value * old_value;
2505 if (reload_every_n_stack_overflow_checks_ > 1000000) {
2506 reload_every_n_stack_overflow_checks_ = 1000000;
2514 forward_table_new_ = std::move(
value);
2518 forward_table_old_ = std::move(
value);
2521void Isolate::Shutdown() {
2531#if !defined(PRODUCT)
2538#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
2540 if (!
group()->HasAttemptedReload()) {
2542 "Isolate did not reload before exiting and "
2543 "--check-reloaded is enabled.\n");
2549 Isolate::UnMarkIsolateReady(
this);
2554 RunAndCleanupFinalizersOnShutdown();
2558 if (bequest_ !=
nullptr) {
2559 auto beneficiary = bequest_->beneficiary();
2560 auto handle = bequest_->TakeHandle();
2570 Isolate::LowLevelCleanup(
this);
2573void Isolate::LowLevelCleanup(Isolate* isolate) {
2574#if !defined(DART_PRECOMPILED_RUNTIME)
2575 if (isolate->is_kernel_isolate()) {
2579 if (isolate->is_service_isolate()) {
2587 auto callback_data = isolate->init_callback_data_;
2591 isolate_group->UnregisterIsolate(isolate);
2604 if (cleanup !=
nullptr) {
2605 cleanup(isolate_group->embedder_data(), callback_data);
2609 const bool shutdown_group = isolate_group->UnregisterIsolateDecrementCount();
2610 if (shutdown_group) {
2616#if !defined(DART_PRECOMPILED_RUNTIME)
2617 BackgroundCompiler::Stop(isolate_group);
2622 FinalizeWeakPersistentHandlesVisitor visitor(isolate_group);
2623 isolate_group->api_state()->VisitWeakHandlesUnlocked(&visitor);
2631 !isolate_group->thread_pool()->CurrentThreadIsWorker()) {
2632 isolate_group->Shutdown();
2634 class ShutdownGroupTask :
public ThreadPool::Task {
2636 explicit ShutdownGroupTask(IsolateGroup* isolate_group)
2637 : isolate_group_(isolate_group) {}
2639 virtual void Run() { isolate_group_->Shutdown(); }
2642 IsolateGroup* isolate_group_;
2647 if (FLAG_trace_shutdown) {
2670Random* IsolateGroup::isolate_group_random_ =
nullptr;
2671Monitor* Isolate::isolate_creation_monitor_ =
nullptr;
2672bool Isolate::creation_enabled_ =
false;
2674RwLock* IsolateGroup::isolate_groups_rwlock_ =
nullptr;
2675IntrusiveDList<IsolateGroup>* IsolateGroup::isolate_groups_ =
nullptr;
2677void Isolate::VisitObjectPointers(ObjectPointerVisitor* visitor,
2679 ASSERT(visitor !=
nullptr);
2684 if (!visitor->trace_values_through_fields()) {
2693 visitor->clear_gc_root_type();
2695 visitor->VisitPointer(
reinterpret_cast<ObjectPtr*
>(¤t_tag_));
2696 visitor->VisitPointer(
reinterpret_cast<ObjectPtr*
>(&default_tag_));
2697 visitor->VisitPointer(
reinterpret_cast<ObjectPtr*
>(&tag_table_));
2698 visitor->VisitPointer(
reinterpret_cast<ObjectPtr*
>(&sticky_error_));
2699 visitor->VisitPointer(
reinterpret_cast<ObjectPtr*
>(&finalizers_));
2700#if !defined(PRODUCT)
2701 visitor->VisitPointer(
2702 reinterpret_cast<ObjectPtr*
>(&pending_service_extension_calls_));
2703 visitor->VisitPointer(
2704 reinterpret_cast<ObjectPtr*
>(®istered_service_extension_handlers_));
2707#if !defined(PRODUCT)
2712 if (is_service_isolate()) {
2717#if !defined(DART_PRECOMPILED_RUNTIME)
2724 visitor->VisitPointer(
2725 reinterpret_cast<ObjectPtr*
>(&loaded_prefixes_set_storage_));
2727 if (pointers_to_verify_at_exit_.length() != 0) {
2728 visitor->VisitPointers(&pointers_to_verify_at_exit_[0],
2729 pointers_to_verify_at_exit_.length());
2733void Isolate::VisitStackPointers(ObjectPointerVisitor* visitor,
2761 ASSERT(loaded_prefixes_set_storage_ ==
nullptr);
2762 loaded_prefixes_set_storage_ =
2763 HashTables::New<UnorderedHashSet<LibraryPrefixMapTraits> >(4);
2768 loaded_prefixes_set_storage_);
2770 loaded_prefixes_set.Release();
2776 loaded_prefixes_set_storage_);
2778 loaded_prefixes_set_storage_ = loaded_prefixes_set.Release().ptr();
2784 ASSERT(marking_stack_ ==
nullptr);
2793 ASSERT(marking_stack_ !=
nullptr);
2794 marking_stack_ =
nullptr;
2795 deferred_marking_stack_ =
nullptr;
2800 bool at_safepoint) {
2808 for (
Isolate* isolate : isolates_) {
2814 for (
Isolate* isolate : isolates_) {
2820 for (
Isolate* isolate : isolates_) {
2831 return isolates_.IsEmpty() ? nullptr : isolates_.First();
2837 bool use_force_growth_in_otherwise) {
2843 single_current_mutator->
Call();
2850 single_current_mutator->
Call();
2858 if (use_force_growth_in_otherwise) {
2871 for (
Isolate* isolate : isolates_) {
2872 isolate->VisitObjectPointers(visitor, validate_frames);
2899#if !defined(PRODUCT)
2905#if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME)
2914 if (
source()->loaded_blobs_ !=
nullptr) {
2919 if (
become() !=
nullptr) {
2932 for (
Isolate* isolate : isolates_) {
2935 isolate->VisitStackPointers(visitor, validate_frames);
2942#if !defined(PRODUCT)
2943 for (
Isolate* isolate : isolates_) {
2945 if (ring !=
nullptr) {
2967#if !defined(PRODUCT)
2969 if (object_id_ring_ ==
nullptr) {
2972 return object_id_ring_;
3014 ((isolate->
debugger() ==
nullptr) ||
3017 }
else if ((isolate->
debugger() !=
nullptr) &&
3024#if !defined(DART_PRECOMPILED_RUNTIME)
3025 if (isolate->
debugger() !=
nullptr) {
3028 if (stack->
Length() > 0) {
3040 jsobj.
AddProperty(
"type", (ref ?
"@Isolate" :
"Isolate"));
3046 jsobj.
AddProperty(
"isSystemIsolate", is_system_isolate());
3066#define TO_STRING(s) STR(s)
3069#define ADD_ISOLATE_FLAGS(when, name, bitname, isolate_flag_name, flag_name) \
3071 JSONObject jsflag(&jsflags); \
3072 jsflag.AddProperty("name", TO_STRING(name)); \
3073 jsflag.AddProperty("valueAsString", name() ? "true" : "false"); \
3075 JSONArray jsflags(&jsobj,
"isolateFlags");
3077#undef ADD_ISOLATE_FLAGS
3083 jsobj.
AddProperty(
"livePorts", open_ports_keepalive_);
3085#if !defined(DART_PRECOMPILED_RUNTIME)
3097 if (FLAG_profiler) {
3098 JSONObject tagCounters(&jsobj,
"_tagCounters");
3114 intptr_t num_libs = libs.Length();
3117 JSONArray lib_array(&jsobj,
"libraries");
3118 for (intptr_t i = 0; i < num_libs; i++) {
3126 JSONArray breakpoints(&jsobj,
"breakpoints");
3139 JSONObject settings(&jsobj,
"_debuggerSettings");
3146 if (!handlers.
IsNull()) {
3147 JSONArray extensions(&jsobj,
"extensionRPCs");
3149 for (intptr_t i = 0; i < handlers.
Length(); i += kRegisteredEntrySize) {
3150 handler_name ^= handlers.
At(i + kRegisteredNameIndex);
3151 extensions.AddValue(handler_name.
ToCString());
3157 JSONObject isolate_group(&jsobj,
"isolate_group");
3173 tag_table_ =
value.ptr();
3180 current_tag_ = tag.
ptr();
3184 default_tag_ = tag.
ptr();
3189 ErrorPtr return_value = sticky_error_;
3191 return return_value;
3194#if !defined(PRODUCT)
3195void Isolate::set_pending_service_extension_calls(
3197 pending_service_extension_calls_ =
value.ptr();
3200void Isolate::set_registered_service_extension_handlers(
3201 const GrowableObjectArray& value) {
3202 registered_service_extension_handlers_ =
value.ptr();
3220 const Array& arguments =
3229 for (intptr_t i = 0; i < calls.
Length(); i += kPendingEntrySize) {
3231 closure ^= calls.
At(i + kPendingHandlerIndex);
3232 ASSERT(!closure.IsNull());
3233 arguments.
SetAt(kPendingHandlerIndex, closure);
3234 method_name ^= calls.
At(i + kPendingMethodNameIndex);
3236 arguments.
SetAt(kPendingMethodNameIndex, method_name);
3237 parameter_keys ^= calls.
At(i + kPendingKeysIndex);
3239 arguments.
SetAt(kPendingKeysIndex, parameter_keys);
3240 parameter_values ^= calls.
At(i + kPendingValuesIndex);
3242 arguments.
SetAt(kPendingValuesIndex, parameter_values);
3243 reply_port ^= calls.
At(i + kPendingReplyPortIndex);
3245 arguments.
SetAt(kPendingReplyPortIndex, reply_port);
3246 id ^= calls.
At(i + kPendingIdIndex);
3247 arguments.
SetAt(kPendingIdIndex,
id);
3248 arguments.
SetAt(kPendingEntrySize,
Bool::Get(FLAG_trace_service));
3250 if (FLAG_trace_service) {
3255 if (FLAG_trace_service) {
3262 if (!
result.IsUnwindError()) {
3265 reply_port,
id, Error::Cast(
result));
3267 return Error::Cast(
result).ptr();
3274 return Error::Cast(
result).ptr();
3280GrowableObjectArrayPtr Isolate::GetAndClearPendingServiceExtensionCalls() {
3281 GrowableObjectArrayPtr r = pending_service_extension_calls_;
3287 const String& method_name,
3288 const Array& parameter_keys,
3289 const Array& parameter_values,
3292 if (FLAG_trace_service) {
3294 "ms] Isolate %s ENQUEUING request for extension %s\n",
3299 bool schedule_drain =
false;
3303 set_pending_service_extension_calls(calls);
3304 schedule_drain =
true;
3306 ASSERT(kPendingHandlerIndex == 0);
3308 ASSERT(kPendingMethodNameIndex == 1);
3309 calls.
Add(method_name);
3310 ASSERT(kPendingKeysIndex == 2);
3311 calls.
Add(parameter_keys);
3312 ASSERT(kPendingValuesIndex == 3);
3313 calls.
Add(parameter_values);
3314 ASSERT(kPendingReplyPortIndex == 4);
3315 calls.
Add(reply_port);
3316 ASSERT(kPendingIdIndex == 5);
3319 if (schedule_drain) {
3323 msg.
SetAt(0, element);
3325 msg.
SetAt(1, element);
3327 msg.
SetAt(2, element);
3349 set_registered_service_extension_handlers(handlers);
3359 ASSERT(kRegisteredNameIndex == 0);
3361 ASSERT(kRegisteredHandlerIndex == 1);
3366 event.set_extension_rpc(&
name);
3382 for (intptr_t i = 0; i < handlers.
Length(); i += kRegisteredEntrySize) {
3383 handler_name ^= handlers.
At(i + kRegisteredNameIndex);
3392void Isolate::WakePauseEventHandler(
Dart_Isolate isolate) {
3403 if (current_notify_callback != Isolate::WakePauseEventHandler) {
3404 if (current_notify_callback !=
nullptr) {
3405 current_notify_callback(isolate);
3408 ++iso->wake_pause_event_handler_count_;
3418 if (pause_loop_monitor_ ==
nullptr) {
3419 pause_loop_monitor_ =
new Monitor();
3425 ASSERT(wake_pause_event_handler_count_ == 0);
3428#if !defined(DART_PRECOMPILED_RUNTIME)
3429 const bool had_program_reload_context =
3431 const int64_t start_time_micros = !had_program_reload_context
3438 bool resume =
false;
3451#if !defined(DART_PRECOMPILED_RUNTIME)
3452 if (had_program_reload_context &&
3453 (
group()->program_reload_context() ==
nullptr)) {
3454 if (FLAG_trace_reload) {
3455 const int64_t reload_time_micros =
3458 OS::PrintErr(
"Reloading has finished! (%.2f ms)\n", reload_millis);
3472 if (saved_notify_callback !=
nullptr) {
3473 while (wake_pause_event_handler_count_ > 0) {
3475 --wake_pause_event_handler_count_;
3478 wake_pause_event_handler_count_ = 0;
3486 if (visitor ==
nullptr) {
3517 std::unique_ptr<char[]>
result;
3521 const size_t len = strlen(isolate->name()) + 1;
3522 result = std::unique_ptr<char[]>(new char[len]);
3523 strncpy(result.get(), isolate->name(), len);
3530bool Isolate::TryMarkIsolateReady(
Isolate* isolate) {
3532 if (!creation_enabled_) {
3535 isolate->accepts_messages_ =
true;
3539void Isolate::UnMarkIsolateReady(Isolate* isolate) {
3540 MonitorLocker ml(isolate_creation_monitor_);
3541 isolate->accepts_messages_ =
false;
3546 creation_enabled_ =
false;
3551 creation_enabled_ =
true;
3556 return creation_enabled_;
3560 return group->source()->flags.is_system_isolate;
3564 return isolate->is_kernel_isolate() || isolate->is_service_isolate() ||
3568void Isolate::KillLocked(LibMsgId msg_id) {
3578 list_values[0] = &oob;
3583 list_values[1] = &msg_type;
3588 list_values[2] = ∩
3593 list_values[3] = &imm;
3610 bool kill_system_isolates =
false)
3613 kill_system_isolates_(kill_system_isolates) {}
3616 : target_(isolate), msg_id_(msg_id), kill_system_isolates_(
false) {
3624 ASSERT(isolate !=
nullptr);
3625 if (ShouldKill(isolate)) {
3626 if (isolate->AcceptsMessagesLocked()) {
3627 isolate->KillLocked(msg_id_);
3633 bool ShouldKill(
Isolate* isolate) {
3634 if (kill_system_isolates_) {
3635 ASSERT(target_ ==
nullptr);
3641 return (((target_ !=
nullptr) && (isolate == target_)) ||
3647 bool kill_system_isolates_;
3672 ASSERT(spawn_count_ > 0);
3679 ASSERT(thread !=
nullptr);
3681 while (spawn_count_ > 0) {
3691 this, zone, send_function, send_port, &ffi_callback_list_head_);
3698 bool keep_isolate_alive) {
3699 if (keep_isolate_alive) {
3703 this, zone, trampoline,
target, &ffi_callback_list_head_);
3707 ASSERT(0 <= open_ports_ && 0 <= open_ports_keepalive_ &&
3708 open_ports_keepalive_ <= open_ports_);
3709 return open_ports_keepalive_ > 0;
3715 ++open_ports_keepalive_;
3720 bool keep_isolate_alive) {
3722 if (!receive_port.
is_open())
return;
3729 if (keep_isolate_alive) {
3730 ASSERT(open_ports_keepalive_ < open_ports_);
3731 ++open_ports_keepalive_;
3733 ASSERT(0 < open_ports_keepalive_);
3734 --open_ports_keepalive_;
3741 if (!receive_port.
is_open())
return;
3748 --open_ports_keepalive_;
3757 &ffi_callback_list_head_);
3761 ffi_callback_keep_alive_counter_ += delta;
3762 ASSERT(ffi_callback_keep_alive_counter_ >= 0);
3766 ASSERT(ffi_callback_keep_alive_counter_ >= 0);
3767 return ffi_callback_keep_alive_counter_ > 0;
3770#if !defined(PRODUCT)
3773 class_table_ = class_table_->
Clone();
3779 class_table_allocator_.
Free(class_table_);
3780 class_table_ = heap_walk_class_table_;
3786 class_table_allocator_.
Free(heap_walk_class_table_);
3787 heap_walk_class_table_ = class_table_;
static bool match(const char *needle, const char *haystack)
static bool ok(int result)
#define RELEASE_ASSERT(cond)
void store(T arg, std::memory_order order=std::memory_order_release)
void VisitWeakHandlesUnlocked(HandleVisitor *visitor)
void VisitObjectPointersUnlocked(ObjectPointerVisitor *visitor)
static Dart_Handle NewHandle(Thread *thread, ObjectPtr raw)
static Dart_Isolate CastIsolate(Isolate *isolate)
static ObjectPtr UnwrapHandle(Dart_Handle object)
static ArrayPtr New(intptr_t len, Heap::Space space=Heap::kNew)
ObjectPtr At(intptr_t index) const
void SetAt(intptr_t index, const Object &value) const
static ArrayPtr Grow(const Array &source, intptr_t new_length, Heap::Space space=Heap::kNew)
Thread * scheduled_mutator_thread_
void VisitObjectPointers(ObjectPointerVisitor *visitor)
void Add(const Object &before, const Object &after)
static const Bool & Get(bool value)
void Free(ClassTable *table)
void Register(const Class &cls)
ClassPtr At(intptr_t cid) const
void VisitObjectPointers(ObjectPointerVisitor *visitor)
void RegisterTopLevel(const Class &cls)
ClassTable * Clone() const
StringPtr ScrubbedName() const
InstancePtr InsertCanonicalConstant(Zone *zone, const Instance &constant) const
ArrayPtr constants() const
FieldPtr LookupField(const String &name) const
void set_constants(const Array &value) const
bool is_enum_class() const
FieldPtr LookupStaticField(const String &name) const
static ObjectPtr InvokeFunction(const Function &function, const Array &arguments)
static ObjectPtr HandleMessage(Dart_Port port_id, const Instance &message)
static ObjectPtr HandleFinalizerMessage(const FinalizerBase &finalizer)
static ObjectPtr ToString(const Instance &receiver)
static ObjectPtr DrainMicrotaskQueue()
static ThreadPool * thread_pool()
static void ShutdownIsolate(Thread *T)
static int64_t UptimeMillis()
static Isolate * vm_isolate()
ActivationFrame * FrameAt(int i) const
Dart_ExceptionPauseInfo GetExceptionPauseInfo() const
void PrintBreakpointsToJSONArray(JSONArray *jsarr) const
void VisitObjectPointers(ObjectPointerVisitor *visitor)
void PrintSettingsToJSONObject(JSONObject *jsobj) const
DebuggerStackTrace * StackTrace()
ErrorPtr PausePostRequest()
const ServiceEvent * PauseEvent() const
void SetExceptionPauseInfo(Dart_ExceptionPauseInfo pause_info)
void VisitObjectPointers(ObjectPointerVisitor *visitor)
DisableIdleTimerScope(IdleTimeHandler *handler)
static DART_NORETURN void PropagateError(const Error &error)
bool Register(const Field &field, intptr_t expected_field_id=-1)
void Free(intptr_t index)
void SetAt(intptr_t index, ObjectPtr raw_instance, bool concurrent_use=false)
void VisitObjectPointers(ObjectPointerVisitor *visitor)
ObjectPtr StaticConstFieldValue() const
void SetStaticConstFieldValue(const Instance &value, bool assert_initializing_store=true) const
intptr_t field_id() const
void UpdateUnreachable(IsolateGroup *isolate_group)
void VisitHandle(uword addr) override
FinalizeWeakPersistentHandlesVisitor(IsolateGroup *isolate_group)
void VisitObjectPointers(ObjectPointerVisitor *visitor)
void Add(const Object &value, Heap::Space space=Heap::kNew) const
static GrowableObjectArrayPtr New(Heap::Space space=Heap::kNew)
ObjectPtr At(intptr_t index) const
void SetAt(intptr_t index, const Object &value) const
ObjectPtr GetOrNull(const Key &key, bool *present=nullptr) const
ObjectPtr InsertOrGet(const Object &key) const
void SetupImagePage(void *pointer, uword size, bool is_executable)
void PrintMemoryUsageJSON(JSONStream *stream) const
void PrintToJSONObject(Space space, JSONObject *object) const
intptr_t TotalExternalInWords() const
void NotifyIdle(int64_t deadline)
void ResetCanonicalHashTable()
intptr_t TotalCapacityInWords() const
static void Init(IsolateGroup *isolate_group, bool is_vm_isolate, intptr_t max_new_gen_words, intptr_t max_old_gen_words)
intptr_t TotalUsedInWords() const
void InitializeWithHeap(Heap *heap)
bool ShouldNotifyIdle(int64_t *expiry)
bool ShouldCheckForIdle()
void NotifyIdleUsingDefaultDeadline()
void UpdateStartIdleTime()
void NotifyIdle(int64_t deadline)
ObjectPtr GetField(const Field &field) const
InstancePtr Canonicalize(Thread *thread) const
void SetField(const Field &field, const Object &value) const
static InstancePtr New(const Class &cls, Heap::Space space=Heap::kNew)
int64_t start_time_micros() const
void add_loaded_blob(Zone *zone_, const ExternalTypedData &external_typed_data)
void IncreaseMutatorCount(Isolate *mutator, bool is_nested_reenter)
GroupDebugger * debugger() const
void RunWithLockedGroup(std::function< void()> fun)
int64_t UptimeMicros() const
void RestoreOriginalClassTable()
bool ReloadKernel(JSONStream *js, bool force_reload, const uint8_t *kernel_buffer=nullptr, intptr_t kernel_buffer_size=0, bool dont_delete_reload_context=false)
void UnregisterIsolate(Isolate *isolate)
void ForEachIsolate(std::function< void(Isolate *isolate)> function, bool at_safepoint=false)
void set_cached_class_table_table(ClassPtr *cached_class_table_table)
bool UnregisterIsolateDecrementCount()
void DeleteReloadContext()
void VisitStackPointers(ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)
MutatorThreadPool * thread_pool()
static bool IsSystemIsolateGroup(const IsolateGroup *group)
void ScheduleInterrupts(uword interrupt_bits)
void RegisterClass(const Class &cls)
void * embedder_data() const
void RehashConstants(Become *become)
void FlagsCopyFrom(const Dart_IsolateFlags &api_flags)
void DropOriginalClassTable()
MarkingStack * deferred_marking_stack() const
bool initial_spawn_successful()
bool ContainsOnlyOneIsolate()
void FreeStaticField(const Field &field)
ObjectStore * object_store() const
SafepointRwLock * program_lock()
void DisableIncrementalBarrier()
void CloneClassTableForReload()
static IsolateGroup * Current()
Dart_LibraryTagHandler library_tag_handler() const
void RegisterStaticField(const Field &field, const Object &initial_value)
ClassTable * class_table() const
static bool HasOnlyVMIsolateGroup()
bool is_system_isolate_group() const
void DecreaseMutatorCount(Isolate *mutator, bool is_nested_exit)
void VisitObjectIdRingPointers(ObjectPointerVisitor *visitor)
void set_object_store(ObjectStore *object_store)
ApiState * api_state() const
FieldTable * initial_field_table() const
void VisitObjectPointers(ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)
IsolateGroupSource * source() const
bool ReloadSources(JSONStream *js, bool force_reload, const char *root_script_url=nullptr, const char *packages_url=nullptr, bool dont_delete_reload_context=false)
void set_saved_unlinked_calls(const Array &saved_unlinked_calls)
void SetHasAttemptedReload(bool value)
void SetupImagePage(const uint8_t *snapshot_buffer, bool is_executable)
ClassTable * heap_walk_class_table() const
ArrayPtr saved_unlinked_calls() const
Isolate * FirstIsolateLocked() const
void PrintJSON(JSONStream *stream, bool ref=true)
void EnableIncrementalBarrier(MarkingStack *marking_stack, MarkingStack *deferred_marking_stack)
void ReleaseStoreBuffers()
static void ExitTemporaryIsolate()
void RememberLiveTemporaries()
void FlagsCopyTo(Dart_IsolateFlags *api_flags)
void RunWithStoppedMutatorsCallable(Callable *single_current_mutator, Callable *otherwise, bool use_force_growth_in_otherwise=false)
void VisitWeakPersistentHandles(HandleVisitor *visitor)
static void RunWithIsolateGroup(uint64_t id, std::function< void(IsolateGroup *)> action, std::function< void()> not_found)
void DeferredMarkLiveTemporaries()
void RegisterIsolate(Isolate *isolate)
void MaybeIncreaseReloadEveryNStackOverflowChecks()
BackgroundCompiler * background_compiler() const
static void RegisterIsolateGroup(IsolateGroup *isolate_group)
MarkingStack * marking_stack() const
ThreadRegistry * thread_registry() const
Isolate * FirstIsolate() const
ObjectPtr CallTagHandler(Dart_LibraryTag tag, const Object &arg1, const Object &arg2)
IdleTimeHandler * idle_time_handler()
bool is_vm_isolate() const
Isolate * EnterTemporaryIsolate()
static bool HasApplicationIsolateGroups()
Dart_DeferredLoadHandler deferred_load_handler() const
void PrintToJSONObject(JSONObject *jsobj, bool ref)
static void ForEach(std::function< void(IsolateGroup *)> action)
void FlushMarkingStacks()
ProgramReloadContext * program_reload_context()
void VisitSharedPointers(ObjectPointerVisitor *visitor)
static void FlagsInitialize(Dart_IsolateFlags *api_flags)
void CreateHeap(bool is_vm_isolate, bool is_service_or_kernel_isolate)
IsolateGroup(std::shared_ptr< IsolateGroupSource > source, void *embedder_data, ObjectStore *object_store, Dart_IsolateFlags api_flags, bool is_vm_isolate)
static void UnregisterIsolateGroup(IsolateGroup *isolate_group)
bool HasTagHandler() const
void PrintMemoryUsageJSON(JSONStream *stream)
virtual ~IsolateKillerVisitor()
void VisitIsolate(Isolate *isolate)
IsolateKillerVisitor(Isolate *isolate, Isolate::LibMsgId msg_id)
IsolateKillerVisitor(Isolate::LibMsgId msg_id, bool kill_system_isolates=false)
MessageStatus HandleMessage(std::unique_ptr< Message > message)
virtual Isolate * isolate() const
bool IsCurrentIsolate() const
virtual bool KeepAliveLocked()
const char * name() const
IsolateMessageHandler(Isolate *isolate)
void MessageNotify(Message::Priority priority)
virtual IsolateGroup * isolate_group() const
void NotifyPauseOnStart()
void VisitObjectPointers(ObjectPointerVisitor *visitor)
virtual void VisitIsolate(Isolate *isolate)=0
bool IsSystemIsolate(Isolate *isolate) const
void set_forward_table_old(WeakTable *table)
ReceivePortPtr CreateReceivePort(const String &debug_name)
bool AddResumeCapability(const Capability &capability)
void AddExitListener(const SendPort &listener, const Instance &response)
void AddErrorListener(const SendPort &listener)
FfiCallbackMetadata::Trampoline CreateAsyncFfiCallback(Zone *zone, const Function &send_function, Dart_Port send_port)
ErrorPtr sticky_error() const
static bool IsSystemIsolate(const Isolate *isolate)
FieldTable * field_table() const
static void DisableIsolateCreation()
void ScheduleInterrupts(uword interrupt_bits)
void RememberLiveTemporaries()
@ kDrainServiceExtensionsMsg
static Isolate * Current()
static bool IsVMInternalIsolate(const Isolate *isolate)
void DeferredMarkLiveTemporaries()
static void KillIfExists(Isolate *isolate, LibMsgId msg_id)
static bool IsolateCreationEnabled()
IsolateObjectStore * isolate_object_store() const
void FlagsCopyTo(Dart_IsolateFlags *api_flags) const
VMTagCounters * vm_tag_counters()
static void KillAllSystemIsolates(LibMsgId msg_id)
static void VisitIsolates(IsolateVisitor *visitor)
Debugger * debugger() const
bool VerifyPauseCapability(const Object &capability) const
void DeleteFfiCallback(FfiCallbackMetadata::Trampoline callback)
void NotifyExitListeners()
bool IsPrefixLoaded(const LibraryPrefix &prefix) const
void DecrementSpawnCount()
bool RemoveResumeCapability(const Capability &capability)
void PrintJSON(JSONStream *stream, bool ref=true)
bool ResumeRequest() const
MessageHandler * message_handler() const
ObjectPtr CallDeferredLoadHandler(intptr_t id)
void PrintPauseEventJSON(JSONStream *stream)
bool is_vm_isolate() const
void SetReceivePortKeepAliveState(const ReceivePort &receive_port, bool keep_isolate_alive)
FfiCallbackMetadata::Trampoline CreateIsolateLocalFfiCallback(Zone *zone, const Function &trampoline, const Closure &target, bool keep_isolate_alive)
void SetPrefixIsLoaded(const LibraryPrefix &prefix)
void RegisterServiceExtensionHandler(const String &name, const Instance &closure)
static void FlagsInitialize(Dart_IsolateFlags *api_flags)
void PrintMemoryUsageJSON(JSONStream *stream)
static void KillAllIsolates(LibMsgId msg_id)
static std::unique_ptr< char[]> LookupIsolateNameByPort(Dart_Port port)
bool HasPendingMessages()
static intptr_t IsolateListLength()
uint64_t terminate_capability() const
ThreadRegistry * thread_registry() const
void set_is_runnable(bool value)
void CloseReceivePort(const ReceivePort &receive_port)
bool HasDeferredLoadHandler() const
const char * MakeRunnable()
void SendInternalLibMessage(LibMsgId msg_id, uint64_t capability)
bool VerifyTerminateCapability(const Object &capability) const
void WaitForOutstandingSpawns()
void set_forward_table_new(WeakTable *table)
int64_t UptimeMicros() const
void UpdateNativeCallableKeepIsolateAliveCounter(intptr_t delta)
ObjectIdRing * EnsureObjectIdRing()
ErrorPtr InvokePendingServiceExtensionCalls()
void MakeRunnableLocked()
DART_WARN_UNUSED_RESULT ErrorPtr StealStickyError()
ErrorPtr PausePostRequest()
static void EnableIsolateCreation()
void AppendServiceExtensionCall(const Instance &closure, const String &method_name, const Array ¶meter_keys, const Array ¶meter_values, const Instance &reply_port, const Instance &id)
IsolateGroup * group() const
void set_current_tag(const UserTag &tag)
Dart_MessageNotifyCallback message_notify_callback() const
InstancePtr LookupServiceExtensionHandler(const String &name)
void set_name(const char *name)
static Dart_IsolateGroupCleanupCallback GroupCleanupCallback()
void FlagsCopyFrom(const Dart_IsolateFlags &api_flags)
void set_finalizers(const GrowableObjectArray &value)
void RemoveExitListener(const SendPort &listener)
uint64_t pause_capability() const
static Isolate * LookupIsolateByPort(Dart_Port port)
bool NotifyErrorListeners(const char *msg, const char *stacktrace)
void init_loaded_prefixes_set_storage()
void set_tag_table(const GrowableObjectArray &value)
friend class IsolateGroup
DeoptContext * deopt_context() const
Thread * mutator_thread() const
void set_default_tag(const UserTag &tag)
void IncrementSpawnCount()
void set_origin_id(Dart_Port id)
void RemoveErrorListener(const SendPort &listener)
void set_message_notify_callback(Dart_MessageNotifyCallback value)
Dart_Port main_port() const
void SetStickyError(ErrorPtr sticky_error)
const char * name() const
bool HasOpenNativeCallables()
void AddValue(bool b) const
void AddProperty64(const char *name, int64_t i) const
void AddProperty(const char *name, bool b) const
void AddServiceId(const Object &o) const
void AddPropertyTimeMillis(const char *name, int64_t millis) const
void AddPropertyF(const char *name, const char *format,...) const PRINTF_ATTRIBUTE(3
static void NotifyAboutIsolateGroupShutdown(const IsolateGroup *isolate_group)
static void SetKernelIsolate(Isolate *isolate)
static uword Hash(const Object &obj)
static bool IsMatch(const Object &a, const Object &b)
static const char * Name()
static bool ReportStats()
FunctionPtr LookupFunctionAllowPrivate(const String &name) const
static LibraryPtr DeveloperLibrary()
static void PrintSizes(Thread *thread)
virtual bool KeepAliveLocked()
bool Run(ThreadPool *pool, StartCallback start_callback, EndCallback end_callback, CallbackData data)
bool is_paused_on_start() const
bool is_paused_on_exit() const
bool should_pause_on_start() const
static std::unique_ptr< Message > New(Args &&... args)
@ kDelayedIsolateLibOOBMsg
static const Dart_Port kIllegalPort
Monitor::WaitResult WaitMicros(int64_t micros=Monitor::kNoTimeout)
Monitor::WaitResult WaitWithSafepointCheck(Thread *thread, int64_t millis=Monitor::kNoTimeout)
Monitor::WaitResult Wait(int64_t millis=Monitor::kNoTimeout)
virtual void OnEnterIdleLocked(MonitorLocker *ml)
bool IsOwnedByCurrentThread() const
static OSThread * Current()
static int64_t GetCurrentTimeMillis()
static int64_t GetCurrentMonotonicMicros()
static void static void PrintErr(const char *format,...) PRINTF_ATTRIBUTE(1
static char * SCreate(Zone *zone, const char *format,...) PRINTF_ATTRIBUTE(2
void VisitPointers(ObjectPointerVisitor *visitor)
void clear_gc_root_type()
void set_gc_root_type(const char *gc_root_type)
void VisitPointer(ObjectPtr *p)
void VisitObjectPointers(ObjectPointerVisitor *visitor)
void ClearCanonical() const
intptr_t GetClassId() const
bool InVMIsolateHeap() const
static ObjectPtr RawCast(ObjectPtr obj)
void AbandonMarkingForShutdown()
Monitor * tasks_lock() const
static bool PostMessage(std::unique_ptr< Message > message, bool before_events=false)
static bool ClosePort(Dart_Port id, MessageHandler **message_handler=nullptr)
static void ClosePorts(MessageHandler *handler)
static Dart_Port CreatePort(MessageHandler *handler)
static void IsolateShutdown(Thread *thread)
IsolateGroupReloadContext * group_reload_context()
void set_keep_isolate_alive(bool value) const
void set_is_open(bool value) const
static ReceivePortPtr New(Dart_Port id, const String &debug_name, Heap::Space space=Heap::kNew)
bool keep_isolate_alive() const
static intptr_t MaxMutatorThreadCount()
void set_top_frame(ActivationFrame *frame)
void PrintJSON(JSONStream *js) const
static void SetServiceIsolate(Isolate *isolate)
static void VisitObjectPointers(ObjectPointerVisitor *visitor)
static bool SendIsolateShutdownMessage()
static StreamInfo isolate_stream
static void HandleEvent(ServiceEvent *event, bool enter_safepoint=true)
static StreamInfo debug_stream
static ErrorPtr HandleIsolateMessage(Isolate *isolate, const Array &message)
static void PostError(const String &method_name, const Array ¶meter_keys, const Array ¶meter_values, const Instance &reply_port, const Instance &id, const Error &error)
static SmiPtr New(intptr_t value)
bool Equals(const String &str) const
static StringPtr New(const char *cstr, Heap::Space space=Heap::kNew)
static const char * ToCString(Thread *thread, StringPtr ptr)
static StringPtr FromConcat(Thread *thread, const String &str1, const String &str2)
static void DumpStats(IsolateGroup *isolate_group)
bool ShuttingDownLocked()
bool Run(Args &&... args)
void MarkCurrentWorkerAsBlocked()
void MarkCurrentWorkerAsUnBlocked()
bool TasksWaitingToRunLocked()
void ReleaseStoreBuffers()
void FlushMarkingStacks()
void VisitObjectPointers(IsolateGroup *isolate_group_of_interest, ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)
void AcquireMarkingStacks()
void ReleaseMarkingStacks()
static ThreadState * Current()
void set_execution_state(ExecutionState state)
void ScheduleInterrupts(uword interrupt_bits)
void RememberLiveTemporaries()
bool OwnsSafepoint() const
static Thread * Current()
void VisitObjectPointers(ObjectPointerVisitor *visitor, ValidationPolicy validate_frames)
void set_sticky_error(const Error &value)
static void ExitIsolateGroupAsHelper(bool bypass_safepoint)
bool IsDartMutatorThread() const
Isolate * isolate() const
TaskKind task_kind() const
static void EnterIsolate(Isolate *isolate)
static void ExitIsolate(bool isolate_shutdown=false)
static bool EnterIsolateGroupAsHelper(IsolateGroup *isolate_group, TaskKind kind, bool bypass_safepoint)
void DeferredMarkLiveTemporaries()
static UnwindErrorPtr New(const String &message, Heap::Space space=Heap::kNew)
bool is_user_initiated() const
static char * StrDup(const char *s)
void PrintToJSONObject(JSONObject *obj)
static WeakPropertyPtr New(Heap::Space space=Heap::kNew)
void set_key(const Object &key) const
ElementType * Alloc(intptr_t length)
#define THR_Print(format,...)
#define DART_FLAGS_CURRENT_VERSION
void(* Dart_UnregisterKernelBlobCallback)(const char *kernel_blob_uri)
Dart_Isolate(* Dart_IsolateGroupCreateCallback)(const char *script_uri, const char *main, const char *package_root, const char *package_config, Dart_IsolateFlags *flags, void *isolate_data, char **error)
void(* Dart_IsolateCleanupCallback)(void *isolate_group_data, void *isolate_data)
void(* Dart_MessageNotifyCallback)(Dart_Isolate destination_isolate)
struct _Dart_Handle * Dart_Handle
const char *(* Dart_RegisterKernelBlobCallback)(const uint8_t *kernel_buffer, intptr_t kernel_buffer_size)
struct _Dart_Isolate * Dart_Isolate
bool(* Dart_InitializeIsolateCallback)(void **child_isolate_data, char **error)
void(* Dart_IsolateGroupCleanupCallback)(void *isolate_group_data)
void(* Dart_IsolateShutdownCallback)(void *isolate_group_data, void *isolate_data)
#define CHECK_ISOLATE_GROUP(isolate_group)
@ Dart_CObject_kCapability
FlutterSemanticsFlag flags
FlKeyEvent uint64_t FlKeyResponderAsyncCallback callback
const uint8_t uint32_t uint32_t GError ** error
#define DECLARE_FLAG(type, name)
#define DEFINE_FLAG(type, name, default_value, comment)
#define DEFINE_FLAG_HANDLER(handler, name, comment)
Dart_NativeFunction function
#define BOOL_ISOLATE_FLAG_LIST(V)
#define BOOL_ISOLATE_GROUP_FLAG_LIST(V)
#define RELOAD_OPERATION_SCOPE(thread_expr)
#define ISOLATE_METRIC_LIST(V)
#define ISOLATE_GROUP_METRIC_LIST(V)
DART_EXPORT bool Dart_HasServiceMessages()
static const char * ExceptionPauseInfoToServiceEnum(Dart_ExceptionPauseInfo pi)
static void DeterministicModeHandler(bool value)
constexpr intptr_t kMicrosecondsPerMillisecond
ObjectPtr ReadMessage(Thread *thread, Message *message)
DART_EXPORT void Dart_EnterScope()
DART_EXPORT void Dart_EnterIsolate(Dart_Isolate isolate)
static std::unique_ptr< Message > SerializeMessage(Dart_Port dest_port, const Instance &obj)
constexpr uword kUwordMax
static void ShutdownIsolate(uword parameter)
constexpr intptr_t MBInWords
AsThreadStackResource< RawReloadParticipationScope > ReloadParticipationScope
const intptr_t kDefaultMaxOldGenHeapSize
DART_EXPORT void Dart_ExitScope()
std::unique_ptr< Message > WriteMessage(bool same_group, const Object &obj, Dart_Port dest_port, Message::Priority priority)
static ServiceEvent IsolatePauseEvent(Isolate *isolate)
constexpr intptr_t kWordSize
std::unique_ptr< Message > WriteApiMessage(Zone *zone, Dart_CObject *obj, Dart_Port dest_port, Message::Priority priority)
constexpr double MicrosecondsToMilliseconds(int64_t micros)
static MessageHandler::MessageStatus StoreError(Thread *thread, const Error &error)
DART_EXPORT void Dart_ShutdownIsolate()
DART_EXPORT bool Dart_HandleServiceMessages()
@ kPauseOnUnhandledExceptions
bool IsStringClassId(intptr_t index)
#define ISOLATE_GROUP_SERVICE_ID_FORMAT_STRING
#define ISOLATE_SERVICE_ID_FORMAT_STRING
union _Dart_CObject::@86 value
struct _Dart_CObject::@86::@88 as_capability
struct _Dart_CObject::@86::@89 as_array
struct _Dart_CObject ** values
#define ARRAY_SIZE(array)
#define NOT_IN_PRECOMPILED(code)
#define NOT_IN_PRODUCT(code)
#define ISOLATE_METRIC_PRINT(type, variable, name, unit)
#define ISOLATE_METRIC_INIT(type, variable, name, unit)
#define ISOLATE_GROUP_METRIC_PRINT(type, variable, name, unit)
#define SET_FROM_FLAG(when, name, bitname, isolate_flag, flag)
#define ISOLATE_GROUP_METRIC_CONSTRUCTORS(type, variable, name, unit)
#define INIT_FROM_FLAG(when, name, bitname, isolate_flag, flag)
#define ISOLATE_METRIC_CONSTRUCTORS(type, variable, name, unit)
#define ADD_ISOLATE_FLAGS(when, name, bitname, isolate_flag_name, flag_name)
#define INIT_FROM_FIELD(when, name, bitname, isolate_flag, flag)