From f30a73434641bf318fc2a5ca93f2b3e1747dd9a9 Mon Sep 17 00:00:00 2001 From: "svenpanne@chromium.org" Date: Mon, 16 Sep 2013 13:02:53 +0000 Subject: [PATCH] Add flags to force or prevent setting of isolate.is_memory_constrained. Also enable MAYBE_BOOL flags for when you want to only do something if the flag was explicitly set to true or false. BUG=None R=hpayer@chromium.org, svenpanne@chromium.org Review URL: https://codereview.chromium.org/23890027 Patch from Ross McIlroy . git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16733 ce2b1a6d-e550-0410-aec6-3dcde31c8c00 --- src/api.cc | 3 ++- src/flag-definitions.h | 7 +++++++ src/flags.cc | 29 ++++++++++++++++++++++++++--- src/isolate.cc | 5 +++++ test/cctest/test-flags.cc | 25 +++++++++++++++++++------ 5 files changed, 59 insertions(+), 10 deletions(-) diff --git a/src/api.cc b/src/api.cc index 5b41f92..32f2920 100644 --- a/src/api.cc +++ b/src/api.cc @@ -624,7 +624,8 @@ bool SetResourceConstraints(ResourceConstraints* constraints) { uintptr_t limit = reinterpret_cast(constraints->stack_limit()); isolate->stack_guard()->SetStackLimit(limit); } - if (constraints->is_memory_constrained().has_value) { + if (constraints->is_memory_constrained().has_value && + !i::FLAG_force_memory_constrained.has_value) { isolate->set_is_memory_constrained( constraints->is_memory_constrained().value); } diff --git a/src/flag-definitions.h b/src/flag-definitions.h index cc153af..95fb1f1 100644 --- a/src/flag-definitions.h +++ b/src/flag-definitions.h @@ -148,6 +148,8 @@ public: #endif #define DEFINE_bool(nam, def, cmt) FLAG(BOOL, bool, nam, def, cmt) +#define DEFINE_maybe_bool(nam, cmt) FLAG(MAYBE_BOOL, Maybe, nam, \ + Maybe(), cmt) #define DEFINE_int(nam, def, cmt) FLAG(INT, int, nam, def, cmt) #define DEFINE_float(nam, def, cmt) FLAG(FLOAT, double, nam, def, cmt) #define DEFINE_string(nam, def, cmt) FLAG(STRING, const char*, nam, def, cmt) @@ -600,6 +602,9 @@ DEFINE_int(hash_seed, 0, "Fixed seed to use to hash property keys (0 means random)" "(with snapshots this option cannot override the baked-in seed)") +DEFINE_maybe_bool(force_memory_constrained, + "force (if true) or prevent (if false) the runtime from treating " + "the device as being memory constrained.") // v8.cc DEFINE_bool(preemption, false, @@ -610,6 +615,7 @@ DEFINE_bool(regexp_optimization, true, "generate optimized regexp code") // Testing flags test/cctest/test-{flags,api,serialization}.cc DEFINE_bool(testing_bool_flag, true, "testing_bool_flag") +DEFINE_maybe_bool(testing_maybe_bool_flag, "testing_maybe_bool_flag") DEFINE_int(testing_int_flag, 13, "testing_int_flag") DEFINE_float(testing_float_flag, 2.5, "float-flag") DEFINE_string(testing_string_flag, "Hello, world!", "string-flag") @@ -834,6 +840,7 @@ DEFINE_implication(print_all_code, trace_codegen) #undef FLAG_ALIAS #undef DEFINE_bool +#undef DEFINE_maybe_bool #undef DEFINE_int #undef DEFINE_string #undef DEFINE_float diff --git a/src/flags.cc b/src/flags.cc index 4e18cc8..5ad0ee0 100644 --- a/src/flags.cc +++ b/src/flags.cc @@ -55,7 +55,8 @@ namespace { // to the actual flag, default value, comment, etc. This is designed to be POD // initialized as to avoid requiring static constructors. struct Flag { - enum FlagType { TYPE_BOOL, TYPE_INT, TYPE_FLOAT, TYPE_STRING, TYPE_ARGS }; + enum FlagType { TYPE_BOOL, TYPE_MAYBE_BOOL, TYPE_INT, TYPE_FLOAT, + TYPE_STRING, TYPE_ARGS }; FlagType type_; // What type of flag, bool, int, or string. const char* name_; // Name of the flag, ex "my_flag". @@ -75,6 +76,11 @@ struct Flag { return reinterpret_cast(valptr_); } + Maybe* maybe_bool_variable() const { + ASSERT(type_ == TYPE_MAYBE_BOOL); + return reinterpret_cast*>(valptr_); + } + int* int_variable() const { ASSERT(type_ == TYPE_INT); return reinterpret_cast(valptr_); @@ -133,6 +139,8 @@ struct Flag { switch (type_) { case TYPE_BOOL: return *bool_variable() == bool_default(); + case TYPE_MAYBE_BOOL: + return maybe_bool_variable()->has_value == false; case TYPE_INT: return *int_variable() == int_default(); case TYPE_FLOAT: @@ -157,6 +165,9 @@ struct Flag { case TYPE_BOOL: *bool_variable() = bool_default(); break; + case TYPE_MAYBE_BOOL: + *maybe_bool_variable() = Maybe(); + break; case TYPE_INT: *int_variable() = int_default(); break; @@ -186,6 +197,7 @@ const size_t num_flags = sizeof(flags) / sizeof(*flags); static const char* Type2String(Flag::FlagType type) { switch (type) { case Flag::TYPE_BOOL: return "bool"; + case Flag::TYPE_MAYBE_BOOL: return "maybe_bool"; case Flag::TYPE_INT: return "int"; case Flag::TYPE_FLOAT: return "float"; case Flag::TYPE_STRING: return "string"; @@ -203,6 +215,11 @@ static SmartArrayPointer ToString(Flag* flag) { case Flag::TYPE_BOOL: buffer.Add("%s", (*flag->bool_variable() ? "true" : "false")); break; + case Flag::TYPE_MAYBE_BOOL: + buffer.Add("%s", flag->maybe_bool_variable()->has_value + ? (flag->maybe_bool_variable()->value ? "true" : "false") + : "unset"); + break; case Flag::TYPE_INT: buffer.Add("%d", *flag->int_variable()); break; @@ -380,6 +397,7 @@ int FlagList::SetFlagsFromCommandLine(int* argc, // if we still need a flag value, use the next argument if available if (flag->type() != Flag::TYPE_BOOL && + flag->type() != Flag::TYPE_MAYBE_BOOL && flag->type() != Flag::TYPE_ARGS && value == NULL) { if (i < *argc) { @@ -399,6 +417,9 @@ int FlagList::SetFlagsFromCommandLine(int* argc, case Flag::TYPE_BOOL: *flag->bool_variable() = !is_bool; break; + case Flag::TYPE_MAYBE_BOOL: + *flag->maybe_bool_variable() = Maybe(!is_bool); + break; case Flag::TYPE_INT: *flag->int_variable() = strtol(value, &endp, 10); // NOLINT break; @@ -425,8 +446,9 @@ int FlagList::SetFlagsFromCommandLine(int* argc, } // handle errors - if ((flag->type() == Flag::TYPE_BOOL && value != NULL) || - (flag->type() != Flag::TYPE_BOOL && is_bool) || + bool is_bool_type = flag->type() == Flag::TYPE_BOOL || + flag->type() == Flag::TYPE_MAYBE_BOOL; + if ((is_bool_type && value != NULL) || (!is_bool_type && is_bool) || *endp != '\0') { PrintF(stderr, "Error: illegal value for flag %s of type %s\n" "Try --help for options\n", @@ -549,6 +571,7 @@ void FlagList::PrintHelp() { } +// static void FlagList::EnforceFlagImplications() { #define FLAG_MODE_DEFINE_IMPLICATIONS #include "flag-definitions.h" diff --git a/src/isolate.cc b/src/isolate.cc index ceb8809..479fe2f 100644 --- a/src/isolate.cc +++ b/src/isolate.cc @@ -1776,6 +1776,9 @@ Isolate::Isolate() // TODO(bmeurer) Initialized lazily because it depends on flags; can // be fixed once the default isolate cleanup is done. random_number_generator_(NULL), + // TODO(rmcilroy) Currently setting this based on + // FLAG_force_memory_constrained in Isolate::Init; move to here when + // isolate cleanup is done is_memory_constrained_(false), has_fatal_error_(false), use_crankshaft_(true), @@ -2135,6 +2138,8 @@ bool Isolate::Init(Deserializer* des) { TRACE_ISOLATE(init); stress_deopt_count_ = FLAG_deopt_every_n_times; + if (FLAG_force_memory_constrained.has_value) + is_memory_constrained_ = FLAG_force_memory_constrained.value; has_fatal_error_ = false; diff --git a/test/cctest/test-flags.cc b/test/cctest/test-flags.cc index 9cb12c4..ad25beb 100644 --- a/test/cctest/test-flags.cc +++ b/test/cctest/test-flags.cc @@ -54,15 +54,18 @@ TEST(Flags1) { TEST(Flags2) { SetFlagsToDefault(); - int argc = 7; - const char* argv[] = { "Test2", "-notesting-bool-flag", "notaflag", + int argc = 8; + const char* argv[] = { "Test2", "-notesting-bool-flag", + "--notesting-maybe-bool-flag", "notaflag", "--testing_int_flag=77", "-testing_float_flag=.25", "--testing_string_flag", "no way!" }; CHECK_EQ(0, FlagList::SetFlagsFromCommandLine(&argc, const_cast(argv), false)); - CHECK_EQ(7, argc); + CHECK_EQ(8, argc); CHECK(!FLAG_testing_bool_flag); + CHECK(FLAG_testing_maybe_bool_flag.has_value); + CHECK(!FLAG_testing_maybe_bool_flag.value); CHECK_EQ(77, FLAG_testing_int_flag); CHECK_EQ(.25, FLAG_testing_float_flag); CHECK_EQ(0, strcmp(FLAG_testing_string_flag, "no way!")); @@ -73,10 +76,13 @@ TEST(Flags2b) { SetFlagsToDefault(); const char* str = " -notesting-bool-flag notaflag --testing_int_flag=77 " + "-notesting-maybe-bool-flag " "-testing_float_flag=.25 " "--testing_string_flag no_way! "; CHECK_EQ(0, FlagList::SetFlagsFromString(str, StrLength(str))); CHECK(!FLAG_testing_bool_flag); + CHECK(FLAG_testing_maybe_bool_flag.has_value); + CHECK(!FLAG_testing_maybe_bool_flag.value); CHECK_EQ(77, FLAG_testing_int_flag); CHECK_EQ(.25, FLAG_testing_float_flag); CHECK_EQ(0, strcmp(FLAG_testing_string_flag, "no_way!")); @@ -85,9 +91,9 @@ TEST(Flags2b) { TEST(Flags3) { SetFlagsToDefault(); - int argc = 8; + int argc = 9; const char* argv[] = - { "Test3", "--testing_bool_flag", "notaflag", + { "Test3", "--testing_bool_flag", "--testing-maybe-bool-flag", "notaflag", "--testing_int_flag", "-666", "--testing_float_flag", "-12E10", "-testing-string-flag=foo-bar" }; CHECK_EQ(0, FlagList::SetFlagsFromCommandLine(&argc, @@ -95,6 +101,8 @@ TEST(Flags3) { true)); CHECK_EQ(2, argc); CHECK(FLAG_testing_bool_flag); + CHECK(FLAG_testing_maybe_bool_flag.has_value); + CHECK(FLAG_testing_maybe_bool_flag.value); CHECK_EQ(-666, FLAG_testing_int_flag); CHECK_EQ(-12E10, FLAG_testing_float_flag); CHECK_EQ(0, strcmp(FLAG_testing_string_flag, "foo-bar")); @@ -104,11 +112,14 @@ TEST(Flags3) { TEST(Flags3b) { SetFlagsToDefault(); const char* str = - "--testing_bool_flag notaflag --testing_int_flag -666 " + "--testing_bool_flag --testing-maybe-bool-flag notaflag " + "--testing_int_flag -666 " "--testing_float_flag -12E10 " "-testing-string-flag=foo-bar"; CHECK_EQ(0, FlagList::SetFlagsFromString(str, StrLength(str))); CHECK(FLAG_testing_bool_flag); + CHECK(FLAG_testing_maybe_bool_flag.has_value); + CHECK(FLAG_testing_maybe_bool_flag.value); CHECK_EQ(-666, FLAG_testing_int_flag); CHECK_EQ(-12E10, FLAG_testing_float_flag); CHECK_EQ(0, strcmp(FLAG_testing_string_flag, "foo-bar")); @@ -123,6 +134,7 @@ TEST(Flags4) { const_cast(argv), true)); CHECK_EQ(2, argc); + CHECK(!FLAG_testing_maybe_bool_flag.has_value); } @@ -130,6 +142,7 @@ TEST(Flags4b) { SetFlagsToDefault(); const char* str = "--testing_bool_flag --foo"; CHECK_EQ(2, FlagList::SetFlagsFromString(str, StrLength(str))); + CHECK(!FLAG_testing_maybe_bool_flag.has_value); } -- 2.7.4