mirror of
https://github.com/carbon-language/carbon-lang.git
synced 2026-09-24 22:02:23 +01:00
Prabhat SachdevaandRichard Smith
aa8cdd526f
Within `explorer/common/trace_stream.h`, implemented RAII Type `SetProgramPhase`. This RAII type simplifies the process by automatically setting the desired program phase upon construction and restoring the previous phase upon destruction. Co-authored-by: Richard Smith <richard@metafoo.co.uk>
113 lines
4.2 KiB
C++
113 lines
4.2 KiB
C++
// Part of the Carbon Language project, under the Apache License v2.0 with LLVM
|
|
// Exceptions. See /LICENSE for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
|
|
#include "explorer/parse_and_execute/parse_and_execute.h"
|
|
|
|
#include <locale>
|
|
|
|
#include "common/check.h"
|
|
#include "common/error.h"
|
|
#include "explorer/common/trace_stream.h"
|
|
#include "explorer/interpreter/exec_program.h"
|
|
#include "explorer/interpreter/stack_space.h"
|
|
#include "explorer/syntax/parse.h"
|
|
#include "explorer/syntax/prelude.h"
|
|
#include "llvm/ADT/ScopeExit.h"
|
|
|
|
namespace Carbon {
|
|
|
|
// Returns a scope exit function for printing the timing of a step on scope
|
|
// exit. Note the use prints step timings in reverse order.
|
|
static auto PrintTimingOnExit(TraceStream* trace_stream, const char* label,
|
|
std::chrono::steady_clock::time_point* cursor) {
|
|
auto end = std::chrono::steady_clock::now();
|
|
auto duration = end - *cursor;
|
|
*cursor = end;
|
|
auto exit_scope_function = llvm::make_scope_exit([=]() {
|
|
SetProgramPhase set_program_phase(*trace_stream, ProgramPhase::Timing);
|
|
if (trace_stream->is_enabled()) {
|
|
*trace_stream << "Time elapsed in " << label << ": "
|
|
<< std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
duration)
|
|
.count()
|
|
<< "ms\n";
|
|
}
|
|
});
|
|
return exit_scope_function;
|
|
}
|
|
|
|
static auto ParseAndExecuteHelper(std::function<ErrorOr<AST>(Arena*)> parse,
|
|
std::string_view prelude_path,
|
|
Nonnull<TraceStream*> trace_stream,
|
|
Nonnull<llvm::raw_ostream*> print_stream)
|
|
-> ErrorOr<int> {
|
|
return RunWithExtraStack([&]() -> ErrorOr<int> {
|
|
Arena arena;
|
|
auto cursor = std::chrono::steady_clock::now();
|
|
|
|
ErrorOr<AST> parse_result = parse(&arena);
|
|
auto print_parse_time = PrintTimingOnExit(trace_stream, "Parse", &cursor);
|
|
if (!parse_result.ok()) {
|
|
return ErrorBuilder() << "SYNTAX ERROR: " << parse_result.error();
|
|
}
|
|
|
|
AddPrelude(prelude_path, &arena, &parse_result->declarations,
|
|
&parse_result->num_prelude_declarations);
|
|
auto print_prelude_time =
|
|
PrintTimingOnExit(trace_stream, "AddPrelude", &cursor);
|
|
|
|
// Semantically analyze the parsed program.
|
|
ErrorOr<AST> analyze_result =
|
|
AnalyzeProgram(&arena, *parse_result, trace_stream, print_stream);
|
|
auto print_analyze_time =
|
|
PrintTimingOnExit(trace_stream, "AnalyzeProgram", &cursor);
|
|
if (!analyze_result.ok()) {
|
|
return ErrorBuilder() << "COMPILATION ERROR: " << analyze_result.error();
|
|
}
|
|
|
|
// Run the program.
|
|
ErrorOr<int> exec_result =
|
|
ExecProgram(&arena, *analyze_result, trace_stream, print_stream);
|
|
auto print_exec_time =
|
|
PrintTimingOnExit(trace_stream, "ExecProgram", &cursor);
|
|
|
|
if (!exec_result.ok()) {
|
|
return ErrorBuilder() << "RUNTIME ERROR: " << exec_result.error();
|
|
}
|
|
|
|
auto print_trace_timing_heading = llvm::make_scope_exit([=]() {
|
|
SetProgramPhase set_prog_phase(*trace_stream, ProgramPhase::Timing);
|
|
if (trace_stream->is_enabled()) {
|
|
*trace_stream << "********** printing timing **********\n";
|
|
}
|
|
});
|
|
|
|
return exec_result;
|
|
});
|
|
}
|
|
|
|
auto ParseAndExecuteFile(std::string_view prelude_path,
|
|
std::string_view input_file_name, bool parser_debug,
|
|
Nonnull<TraceStream*> trace_stream,
|
|
Nonnull<llvm::raw_ostream*> print_stream)
|
|
-> ErrorOr<int> {
|
|
auto parse = [&](Arena* arena) {
|
|
return Parse(arena, input_file_name, parser_debug);
|
|
};
|
|
return ParseAndExecuteHelper(parse, prelude_path, trace_stream, print_stream);
|
|
}
|
|
|
|
auto ParseAndExecute(std::string_view prelude_path,
|
|
std::string_view input_file_name,
|
|
std::string_view file_contents, bool parser_debug,
|
|
Nonnull<TraceStream*> trace_stream,
|
|
Nonnull<llvm::raw_ostream*> print_stream) -> ErrorOr<int> {
|
|
auto parse = [&](Arena* arena) {
|
|
return ParseFromString(arena, input_file_name, file_contents, parser_debug);
|
|
};
|
|
return ParseAndExecuteHelper(parse, prelude_path, trace_stream, print_stream);
|
|
}
|
|
|
|
} // namespace Carbon
|