Skip to content

Commit 3ef4c19

Browse files
elliottslaughterelliottslaughter
committed
Support for control replication.
1 parent bbbcc02 commit 3ef4c19

File tree

4 files changed

+73
-10
lines changed

4 files changed

+73
-10
lines changed

‎experiment/sapling/run_all_tests.sh

+5-2
Original file line numberDiff line numberDiff line change
@@ -11,13 +11,14 @@ root_dir="$(dirname "$(dirname "$(dirname "$(readlink -f "${BASH_SOURCE[0]}")")"
1111
cd "$root_dir"
1212

1313
export FUZZER_OP_COUNT=1000
14-
export FUZZER_EXTRA_FLAGS="-ll:util 2 -ll:cpu 3"
1514

1615
function run_fuzzer_config {
1716
config_name="$1"
1817
mode="$2"
18+
extra_flags="$3"
1919

2020
fuzzer_exe="$PWD/build_${config_name}/src/fuzzer"
21+
fuzzer_flags="-ll:util 2 -ll:cpu 3 $extra_flags"
2122

2223
if [[ $mode = single ]]; then
2324
test_count=100000
@@ -35,10 +36,12 @@ function run_fuzzer_config {
3536
# Generate a random seed so we explore a novel part of the state space.
3637
seed="$(( 16#$(openssl rand -hex 4) * test_count ))"
3738

38-
FUZZER_EXE="$fuzzer_exe" FUZZER_MODE=$mode FUZZER_TEST_COUNT=$test_count FUZZER_SEED=$seed FUZZER_LAUNCHER="$launcher" sbatch --nodes 1 "experiment/$FUZZER_MACHINE/sbatch_fuzzer.sh"
39+
FUZZER_EXE="$fuzzer_exe" FUZZER_MODE=$mode FUZZER_TEST_COUNT=$test_count FUZZER_SEED=$seed FUZZER_LAUNCHER="$launcher" FUZZER_EXTRA_FLAGS="$fuzzer_flags" sbatch --nodes 1 "experiment/$FUZZER_MACHINE/sbatch_fuzzer.sh"
3940
}
4041

4142
run_fuzzer_config debug_single single
4243
run_fuzzer_config release_single single
4344
run_fuzzer_config debug_multi multi
4445
run_fuzzer_config release_multi multi
46+
run_fuzzer_config debug_multi multi "-fuzz:replicate 1"
47+
run_fuzzer_config release_multi multi "-fuzz:replicate 1"

‎src/fuzzer.cc

+20-2
Original file line numberDiff line numberDiff line change
@@ -20,6 +20,7 @@
2020

2121
#include "deterministic_random.h"
2222
#include "legion.h"
23+
#include "logging_wrapper.h"
2324
#include "mapper.h"
2425

2526
using namespace Legion;
@@ -51,6 +52,8 @@ enum ProjectionIDs {
5152
static Logger log_fuzz("fuzz");
5253

5354
static RngSeed root_seed;
55+
static uint64_t replicate_levels = 0;
56+
static bool mapper_logging = false;
5457

5558
static long long parse_long_long(const std::string &flag, const std::string &arg) {
5659
long long result;
@@ -80,8 +83,10 @@ struct FuzzerConfig {
8083
uint64_t region_tree_branch_factor = 4;
8184
uint64_t region_tree_size_factor = 4;
8285
uint64_t region_tree_num_fields = 4;
86+
uint64_t replicate_levels = 0;
8387
uint64_t num_ops = 1;
8488
uint64_t skip_ops = 0;
89+
bool mapper_logging = false;
8590

8691
static FuzzerConfig parse_args(int argc, char **argv) {
8792
FuzzerConfig config;
@@ -105,12 +110,17 @@ struct FuzzerConfig {
105110
} else if (flag == "-fuzz:fields") {
106111
std::string arg(argv[++i]);
107112
config.region_tree_num_fields = parse_uint64_t(flag, arg);
113+
} else if (flag == "-fuzz:replicate") {
114+
std::string arg(argv[++i]);
115+
config.replicate_levels = parse_uint64_t(flag, arg);
108116
} else if (flag == "-fuzz:ops") {
109117
std::string arg(argv[++i]);
110118
config.num_ops = parse_uint64_t(flag, arg);
111119
} else if (flag == "-fuzz:skip") {
112120
std::string arg(argv[++i]);
113121
config.skip_ops = parse_uint64_t(flag, arg);
122+
} else if (flag == "-fuzz:mapper_logging") {
123+
config.mapper_logging = true;
114124
}
115125
}
116126
return config;
@@ -127,8 +137,10 @@ struct FuzzerConfig {
127137
<< region_tree_size_factor);
128138
LOG_ONCE(log_fuzz.print() << " config.region_tree_num_fields = "
129139
<< region_tree_num_fields);
140+
LOG_ONCE(log_fuzz.print() << " config.replicate_levels = " << replicate_levels);
130141
LOG_ONCE(log_fuzz.print() << " config.num_ops = " << num_ops);
131142
LOG_ONCE(log_fuzz.print() << " config.skip_ops = " << skip_ops);
143+
LOG_ONCE(log_fuzz.print() << " config.mapper_logging = " << mapper_logging);
132144
}
133145
};
134146

@@ -1205,8 +1217,12 @@ void top_level(const Task *task, const std::vector<PhysicalRegion> &regions, Con
12051217
static void create_mappers(Machine machine, Runtime *runtime,
12061218
const std::set<Processor> &local_procs) {
12071219
for (Processor proc : local_procs) {
1208-
FuzzMapper::FuzzMapper *mapper = new FuzzMapper::FuzzMapper(
1209-
runtime->get_mapper_runtime(), machine, proc, root_seed.make_stream());
1220+
Mapping::Mapper *mapper =
1221+
new FuzzMapper::FuzzMapper(runtime->get_mapper_runtime(), machine, proc,
1222+
root_seed.make_stream(), replicate_levels);
1223+
if (mapper_logging) {
1224+
mapper = new Mapping::LoggingWrapper(mapper);
1225+
}
12101226
runtime->replace_default_mapper(mapper, proc);
12111227
}
12121228
}
@@ -1219,6 +1235,8 @@ int main(int argc, char **argv) {
12191235
Runtime::initialize(&argc, &argv, true /* filter */);
12201236
FuzzerConfig config = FuzzerConfig::parse_args(argc, argv);
12211237
root_seed = RngSeed(config.initial_seed);
1238+
replicate_levels = config.replicate_levels;
1239+
mapper_logging = config.mapper_logging;
12221240

12231241
Runtime::preregister_projection_functor(PROJECTION_OFFSET_1_ID,
12241242
new OffsetProjection(1));

‎src/mapper.cc

+41-5
Original file line numberDiff line numberDiff line change
@@ -31,13 +31,15 @@ enum MapperCallIDs {
3131

3232
static Logger log_map("fuzz_mapper");
3333

34-
FuzzMapper::FuzzMapper(MapperRuntime *rt, Machine machine, Processor local, RngStream st)
34+
FuzzMapper::FuzzMapper(MapperRuntime *rt, Machine machine, Processor local, RngStream st,
35+
uint64_t replicate)
3536
: NullMapper(rt, machine),
3637
stream(st),
3738
select_tasks_to_map_channel(st.make_channel(int32_t(SELECT_TASKS_TO_MAP))),
3839
map_inline_channel(st.make_channel(int32_t(MAP_INLINE))),
3940
select_inline_sources_channel(st.make_channel(int32_t(SELECT_INLINE_SOURCES))),
40-
local_proc(local) {
41+
local_proc(local),
42+
replicate_levels(replicate) {
4143
// TODO: something other than CPU processor
4244
{
4345
Machine::ProcessorQuery query(machine);
@@ -85,7 +87,7 @@ void FuzzMapper::select_task_options(const MapperContext ctx, const Task &task,
8587
output.map_locally = false; // TODO
8688
output.valid_instances = false;
8789
output.memoize = true;
88-
output.replicate = task.get_depth() == 0; // TODO: replicate other tasks
90+
output.replicate = task.get_depth() < static_cast<int64_t>(replicate_levels);
8991
// output.parent_priority = ...; // Leave parent at current priority.
9092
// output.check_collective_regions.insert(...); // TODO
9193
}
@@ -124,7 +126,11 @@ void FuzzMapper::map_task(const MapperContext ctx, const Task &task,
124126
log_map.debug() << "map_task: Selected variant " << output.chosen_variant;
125127

126128
// TODO: assign to variant's correct processor kind
127-
if (rng.uniform_range(0, 1) == 0) {
129+
output.target_procs.clear();
130+
if (input.shard_processor.exists()) {
131+
log_map.debug() << "map_task: Mapping to shard proc";
132+
output.target_procs.push_back(input.shard_processor);
133+
} else if (rng.uniform_range(0, 1) == 0) {
128134
log_map.debug() << "map_task: Mapping to all local procs";
129135
output.target_procs.insert(output.target_procs.end(), local_procs.begin(),
130136
local_procs.end());
@@ -149,6 +155,8 @@ void FuzzMapper::map_task(const MapperContext ctx, const Task &task,
149155
void FuzzMapper::replicate_task(MapperContext ctx, const Task &task,
150156
const ReplicateTaskInput &input,
151157
ReplicateTaskOutput &output) {
158+
if (task.get_depth() >= static_cast<int64_t>(replicate_levels)) return;
159+
152160
// TODO: cache this?
153161
std::vector<VariantID> variants;
154162
runtime->find_valid_variants(ctx, task.task_id, variants);
@@ -158,7 +166,28 @@ void FuzzMapper::replicate_task(MapperContext ctx, const Task &task,
158166
abort();
159167
}
160168
output.chosen_variant = variants.at(0);
161-
// TODO: actually replicate
169+
170+
bool is_replicable =
171+
runtime->is_replicable_variant(ctx, task.task_id, output.chosen_variant);
172+
// For now assume we always have replicable variants at this level.
173+
if (!is_replicable) {
174+
log_map.fatal() << "Bad variants in replicate_task: variant is not replicable";
175+
abort();
176+
}
177+
178+
std::map<AddressSpace, Processor> targets;
179+
for (Processor proc : global_procs) {
180+
AddressSpace space = proc.address_space();
181+
if (!targets.count(space)) {
182+
targets[space] = proc;
183+
}
184+
}
185+
186+
if (targets.size() > 1) {
187+
for (auto &target : targets) {
188+
output.target_processors.push_back(target.second);
189+
}
190+
}
162191
}
163192

164193
void FuzzMapper::select_task_sources(const MapperContext ctx, const Task &task,
@@ -168,6 +197,13 @@ void FuzzMapper::select_task_sources(const MapperContext ctx, const Task &task,
168197
random_sources(rng, input.source_instances, output.chosen_ranking);
169198
}
170199

200+
void FuzzMapper::select_sharding_functor(const MapperContext ctx, const Task &task,
201+
const SelectShardingFunctorInput &input,
202+
SelectShardingFunctorOutput &output) {
203+
// TODO: customize the sharding functor
204+
output.chosen_functor = 0;
205+
}
206+
171207
void FuzzMapper::map_inline(const MapperContext ctx, const InlineMapping &inline_op,
172208
const MapInlineInput &input, MapInlineOutput &output) {
173209
RngChannel &rng = map_inline_channel;

‎src/mapper.h

+7-1
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,8 @@ using namespace Legion::Mapping;
2828

2929
class FuzzMapper : public NullMapper {
3030
public:
31-
FuzzMapper(MapperRuntime *runtime, Machine machine, Processor local, RngStream stream);
31+
FuzzMapper(MapperRuntime *runtime, Machine machine, Processor local, RngStream stream,
32+
uint64_t replicate);
3233

3334
public:
3435
const char *get_mapper_name(void) const override;
@@ -49,6 +50,9 @@ class FuzzMapper : public NullMapper {
4950
void select_task_sources(const MapperContext ctx, const Task &task,
5051
const SelectTaskSrcInput &input,
5152
SelectTaskSrcOutput &output) override;
53+
void select_sharding_functor(const MapperContext ctx, const Task &task,
54+
const SelectShardingFunctorInput &input,
55+
SelectShardingFunctorOutput &output) override;
5256

5357
public: // Inline mapping calls
5458
void map_inline(const MapperContext ctx, const InlineMapping &inline_op,
@@ -97,6 +101,8 @@ class FuzzMapper : public NullMapper {
97101
Processor local_proc;
98102
std::vector<Processor> local_procs;
99103
std::vector<Processor> global_procs;
104+
105+
uint64_t replicate_levels;
100106
};
101107

102108
} // namespace FuzzMapper

0 commit comments

Comments
 (0)