| // Copyright 2018 The Amber Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "amber/amber.h" |
| |
| #include <algorithm> |
| #include <cassert> |
| #include <cstdlib> |
| #include <fstream> |
| #include <iomanip> |
| #include <iostream> |
| #include <set> |
| #include <utility> |
| #include <vector> |
| |
| #include "amber/recipe.h" |
| #include "samples/config_helper.h" |
| #include "samples/ppm.h" |
| #include "samples/timestamp.h" |
| #include "src/build-versions.h" |
| #include "src/make_unique.h" |
| |
| #if AMBER_ENABLE_LODEPNG |
| #include "samples/png.h" |
| #endif // AMBER_ENABLE_LODEPNG |
| |
| namespace { |
| |
| const char* kGeneratedColorBuffer = "framebuffer"; |
| |
| struct Options { |
| std::vector<std::string> input_filenames; |
| |
| std::vector<std::string> image_filenames; |
| std::string buffer_filename; |
| std::vector<std::string> fb_names; |
| std::vector<amber::BufferInfo> buffer_to_dump; |
| uint32_t engine_major = 1; |
| uint32_t engine_minor = 0; |
| int32_t fence_timeout = -1; |
| bool parse_only = false; |
| bool pipeline_create_only = false; |
| bool disable_validation_layer = false; |
| bool quiet = false; |
| bool show_help = false; |
| bool show_version_info = false; |
| bool log_graphics_calls = false; |
| bool log_graphics_calls_time = false; |
| bool log_execute_calls = false; |
| bool disable_spirv_validation = false; |
| amber::EngineType engine = amber::kEngineTypeVulkan; |
| std::string spv_env; |
| }; |
| |
| const char kUsage[] = R"(Usage: amber [options] SCRIPT [SCRIPTS...] |
| |
| options: |
| -p -- Parse input files only; Don't execute. |
| -ps -- Parse input files, create pipelines; Don't execute. |
| -q -- Disable summary output. |
| -d -- Disable validation layers. |
| -f <value> -- Sets the fence timeout value to |value| |
| -t <spirv_env> -- The target SPIR-V environment e.g., spv1.3, vulkan1.1. |
| If a SPIR-V environment, assume the lowest version of Vulkan that |
| requires support of that version of SPIR-V. |
| If a Vulkan environment, use the highest version of SPIR-V required |
| to be supported by that version of Vulkan. |
| Use vulkan1.1spv1.4 for SPIR-V 1.4 with Vulkan 1.1. |
| Defaults to spv1.0. |
| -i <filename> -- Write rendering to <filename> as a PNG image if it ends with '.png', |
| or as a PPM image otherwise. |
| -I <buffername> -- Name of framebuffer to dump. Defaults to 'framebuffer'. |
| -b <filename> -- Write contents of a UBO or SSBO to <filename>. |
| -B [<desc set>:]<binding> -- Descriptor set and binding of buffer to write. |
| Default is [0:]0. |
| -e <engine> -- Specify graphics engine: vulkan, dawn. Default is vulkan. |
| -v <engine version> -- Engine version (eg, 1.1 for Vulkan). Default 1.0. |
| -V, --version -- Output version information for Amber and libraries. |
| --log-graphics-calls -- Log graphics API calls (only for Vulkan so far). |
| --log-graphics-calls-time -- Log timing of graphics API calls timing (Vulkan only). |
| --log-execute-calls -- Log each execute call before run. |
| --disable-spirv-val -- Disable SPIR-V validation. |
| -h -- This help text. |
| )"; |
| |
| bool ParseArgs(const std::vector<std::string>& args, Options* opts) { |
| for (size_t i = 1; i < args.size(); ++i) { |
| const std::string& arg = args[i]; |
| if (arg == "-i") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -i argument." << std::endl; |
| return false; |
| } |
| opts->image_filenames.push_back(args[i]); |
| |
| } else if (arg == "-I") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -I argument." << std::endl; |
| return false; |
| } |
| opts->fb_names.push_back(args[i]); |
| |
| } else if (arg == "-b") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -b argument." << std::endl; |
| return false; |
| } |
| opts->buffer_filename = args[i]; |
| |
| } else if (arg == "-B") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -B argument." << std::endl; |
| return false; |
| } |
| opts->buffer_to_dump.emplace_back(); |
| opts->buffer_to_dump.back().buffer_name = args[i]; |
| } else if (arg == "-e") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -e argument." << std::endl; |
| return false; |
| } |
| const std::string& engine = args[i]; |
| if (engine == "vulkan") { |
| opts->engine = amber::kEngineTypeVulkan; |
| } else if (engine == "dawn") { |
| opts->engine = amber::kEngineTypeDawn; |
| } else { |
| std::cerr |
| << "Invalid value for -e argument. Must be one of: vulkan dawn" |
| << std::endl; |
| return false; |
| } |
| } else if (arg == "-f") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -f argument." << std::endl; |
| return false; |
| } |
| |
| int32_t val = std::stoi(std::string(args[i])); |
| if (val < 0) { |
| std::cerr << "Fence timeout must be non-negative" << std::endl; |
| return false; |
| } |
| opts->fence_timeout = val; |
| |
| } else if (arg == "-t") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -t argument." << std::endl; |
| return false; |
| } |
| opts->spv_env = args[i]; |
| } else if (arg == "-h" || arg == "--help") { |
| opts->show_help = true; |
| } else if (arg == "-v") { |
| ++i; |
| if (i >= args.size()) { |
| std::cerr << "Missing value for -v argument." << std::endl; |
| return false; |
| } |
| const std::string& ver = args[i]; |
| |
| size_t dot_pos = 0; |
| int32_t val = std::stoi(ver, &dot_pos); |
| if (val < 0) { |
| std::cerr << "Version major must be non-negative" << std::endl; |
| return false; |
| } |
| |
| opts->engine_major = static_cast<uint32_t>(val); |
| if (dot_pos != std::string::npos && (dot_pos + 1) < ver.size()) { |
| val = std::stoi(ver.substr(dot_pos + 1)); |
| if (val < 0) { |
| std::cerr << "Version minor must be non-negative" << std::endl; |
| return false; |
| } |
| opts->engine_minor = static_cast<uint32_t>(val); |
| } |
| } else if (arg == "-V" || arg == "--version") { |
| opts->show_version_info = true; |
| } else if (arg == "-p") { |
| opts->parse_only = true; |
| } else if (arg == "-ps") { |
| opts->pipeline_create_only = true; |
| } else if (arg == "-d") { |
| opts->disable_validation_layer = true; |
| } else if (arg == "-s") { |
| // -s is deprecated but still recognized, it inverts the quiet flag. |
| opts->quiet = false; |
| } else if (arg == "-q") { |
| opts->quiet = true; |
| } else if (arg == "--log-graphics-calls") { |
| opts->log_graphics_calls = true; |
| } else if (arg == "--log-graphics-calls-time") { |
| opts->log_graphics_calls_time = true; |
| } else if (arg == "--log-execute-calls") { |
| opts->log_execute_calls = true; |
| } else if (arg == "--disable-spirv-val") { |
| opts->disable_spirv_validation = true; |
| } else if (arg.size() > 0 && arg[0] == '-') { |
| std::cerr << "Unrecognized option " << arg << std::endl; |
| return false; |
| } else if (!arg.empty()) { |
| opts->input_filenames.push_back(arg); |
| } |
| } |
| |
| return true; |
| } |
| |
| std::string ReadFile(const std::string& input_file) { |
| FILE* file = nullptr; |
| #if defined(_MSC_VER) |
| fopen_s(&file, input_file.c_str(), "rb"); |
| #else |
| file = fopen(input_file.c_str(), "rb"); |
| #endif |
| if (!file) { |
| std::cerr << "Failed to open " << input_file << std::endl; |
| return {}; |
| } |
| |
| fseek(file, 0, SEEK_END); |
| uint64_t tell_file_size = static_cast<uint64_t>(ftell(file)); |
| if (tell_file_size <= 0) { |
| std::cerr << "Input file of incorrect size: " << input_file << std::endl; |
| fclose(file); |
| return {}; |
| } |
| fseek(file, 0, SEEK_SET); |
| |
| size_t file_size = static_cast<size_t>(tell_file_size); |
| |
| std::vector<char> data; |
| data.resize(file_size); |
| |
| size_t bytes_read = fread(data.data(), sizeof(char), file_size, file); |
| fclose(file); |
| if (bytes_read != file_size) { |
| std::cerr << "Failed to read " << input_file << std::endl; |
| return {}; |
| } |
| |
| return std::string(data.begin(), data.end()); |
| } |
| |
| class SampleDelegate : public amber::Delegate { |
| public: |
| SampleDelegate() = default; |
| ~SampleDelegate() override = default; |
| |
| void Log(const std::string& message) override { |
| std::cout << message << std::endl; |
| } |
| |
| bool LogGraphicsCalls() const override { return log_graphics_calls_; } |
| void SetLogGraphicsCalls(bool log_graphics_calls) { |
| log_graphics_calls_ = log_graphics_calls; |
| } |
| |
| bool LogExecuteCalls() const override { return log_execute_calls_; } |
| void SetLogExecuteCalls(bool log_execute_calls) { |
| log_execute_calls_ = log_execute_calls; |
| } |
| |
| bool LogGraphicsCallsTime() const override { |
| return log_graphics_calls_time_; |
| } |
| void SetLogGraphicsCallsTime(bool log_graphics_calls_time) { |
| log_graphics_calls_time_ = log_graphics_calls_time; |
| if (log_graphics_calls_time) { |
| // Make sure regular logging is also enabled |
| log_graphics_calls_ = true; |
| } |
| } |
| |
| uint64_t GetTimestampNs() const override { |
| return timestamp::SampleGetTimestampNs(); |
| } |
| |
| private: |
| bool log_graphics_calls_ = false; |
| bool log_graphics_calls_time_ = false; |
| bool log_execute_calls_ = false; |
| }; |
| |
| } // namespace |
| |
| int main(int argc, const char** argv) { |
| std::vector<std::string> args(argv, argv + argc); |
| Options options; |
| |
| if (!ParseArgs(args, &options)) { |
| std::cerr << "Failed to parse arguments." << std::endl; |
| return 1; |
| } |
| |
| if (options.show_version_info) { |
| std::cout << "Amber : " << AMBER_VERSION << std::endl; |
| #if AMBER_ENABLE_SPIRV_TOOLS |
| std::cout << "SPIRV-Tools : " << SPIRV_TOOLS_VERSION << std::endl; |
| std::cout << "SPIRV-Headers: " << SPIRV_HEADERS_VERSION << std::endl; |
| #endif // AMBER_ENABLE_SPIRV_TOOLS |
| #if AMBER_ENABLE_SHADERC |
| std::cout << "GLSLang : " << GLSLANG_VERSION << std::endl; |
| std::cout << "Shaderc : " << SHADERC_VERSION << std::endl; |
| #endif // AMBER_ENABLE_SHADERC |
| } |
| |
| if (options.show_help) { |
| std::cout << kUsage << std::endl; |
| return 0; |
| } |
| |
| amber::Result result; |
| std::vector<std::string> failures; |
| struct RecipeData { |
| std::string file; |
| std::unique_ptr<amber::Recipe> recipe; |
| }; |
| std::vector<RecipeData> recipe_data; |
| for (const auto& file : options.input_filenames) { |
| auto data = ReadFile(file); |
| if (data.empty()) { |
| std::cerr << file << " is empty." << std::endl; |
| failures.push_back(file); |
| continue; |
| } |
| |
| amber::Amber am; |
| std::unique_ptr<amber::Recipe> recipe = amber::MakeUnique<amber::Recipe>(); |
| |
| result = am.Parse(data, recipe.get()); |
| if (!result.IsSuccess()) { |
| std::cerr << file << ": " << result.Error() << std::endl; |
| failures.push_back(file); |
| continue; |
| } |
| |
| if (options.fence_timeout > -1) |
| recipe->SetFenceTimeout(static_cast<uint32_t>(options.fence_timeout)); |
| |
| recipe_data.emplace_back(); |
| recipe_data.back().file = file; |
| recipe_data.back().recipe = std::move(recipe); |
| } |
| |
| if (options.parse_only) |
| return 0; |
| |
| SampleDelegate delegate; |
| if (options.log_graphics_calls) |
| delegate.SetLogGraphicsCalls(true); |
| if (options.log_graphics_calls_time) |
| delegate.SetLogGraphicsCallsTime(true); |
| if (options.log_execute_calls) |
| delegate.SetLogExecuteCalls(true); |
| |
| amber::Options amber_options; |
| amber_options.engine = options.engine; |
| amber_options.spv_env = options.spv_env; |
| amber_options.execution_type = options.pipeline_create_only |
| ? amber::ExecutionType::kPipelineCreateOnly |
| : amber::ExecutionType::kExecute; |
| amber_options.delegate = &delegate; |
| amber_options.disable_spirv_validation = options.disable_spirv_validation; |
| |
| std::set<std::string> required_features; |
| std::set<std::string> required_device_extensions; |
| std::set<std::string> required_instance_extensions; |
| for (const auto& recipe_data_elem : recipe_data) { |
| const auto features = recipe_data_elem.recipe->GetRequiredFeatures(); |
| required_features.insert(features.begin(), features.end()); |
| |
| const auto device_extensions = |
| recipe_data_elem.recipe->GetRequiredDeviceExtensions(); |
| required_device_extensions.insert(device_extensions.begin(), |
| device_extensions.end()); |
| |
| const auto inst_extensions = |
| recipe_data_elem.recipe->GetRequiredInstanceExtensions(); |
| required_instance_extensions.insert(inst_extensions.begin(), |
| inst_extensions.end()); |
| } |
| |
| sample::ConfigHelper config_helper; |
| std::unique_ptr<amber::EngineConfig> config; |
| |
| amber::Result r = config_helper.CreateConfig( |
| amber_options.engine, options.engine_major, options.engine_minor, |
| std::vector<std::string>(required_features.begin(), |
| required_features.end()), |
| std::vector<std::string>(required_instance_extensions.begin(), |
| required_instance_extensions.end()), |
| std::vector<std::string>(required_device_extensions.begin(), |
| required_device_extensions.end()), |
| options.disable_validation_layer, options.show_version_info, &config); |
| |
| if (!r.IsSuccess()) { |
| std::cout << r.Error() << std::endl; |
| return 1; |
| } |
| |
| amber_options.config = config.get(); |
| |
| if (!options.buffer_filename.empty()) { |
| // Have a filename to dump, but no explicit buffer, set the default of 0:0. |
| if (options.buffer_to_dump.empty()) { |
| options.buffer_to_dump.emplace_back(); |
| options.buffer_to_dump.back().buffer_name = "0:0"; |
| } |
| |
| amber_options.extractions.insert(amber_options.extractions.end(), |
| options.buffer_to_dump.begin(), |
| options.buffer_to_dump.end()); |
| } |
| |
| if (options.image_filenames.size() - options.fb_names.size() > 1) { |
| std::cerr << "Need to specify framebuffer names using -I for each output " |
| "image specified by -i." |
| << std::endl; |
| return 1; |
| } |
| |
| // Use default frame buffer name when not specified. |
| while (options.image_filenames.size() > options.fb_names.size()) |
| options.fb_names.push_back(kGeneratedColorBuffer); |
| |
| for (const auto& fb_name : options.fb_names) { |
| amber::BufferInfo buffer_info; |
| buffer_info.buffer_name = fb_name; |
| buffer_info.is_image_buffer = true; |
| amber_options.extractions.push_back(buffer_info); |
| } |
| |
| for (const auto& recipe_data_elem : recipe_data) { |
| const auto* recipe = recipe_data_elem.recipe.get(); |
| const auto& file = recipe_data_elem.file; |
| |
| amber::Amber am; |
| result = am.Execute(recipe, &amber_options); |
| if (!result.IsSuccess()) { |
| std::cerr << file << ": " << result.Error() << std::endl; |
| failures.push_back(file); |
| // Note, we continue after failure to allow dumping the buffers which may |
| // give clues as to the failure. |
| } |
| |
| for (size_t i = 0; i < options.image_filenames.size(); ++i) { |
| std::vector<uint8_t> out_buf; |
| auto image_filename = options.image_filenames[i]; |
| auto pos = image_filename.find_last_of('.'); |
| bool usePNG = |
| pos != std::string::npos && image_filename.substr(pos + 1) == "png"; |
| for (const amber::BufferInfo& buffer_info : amber_options.extractions) { |
| if (buffer_info.buffer_name == options.fb_names[i]) { |
| if (usePNG) { |
| #if AMBER_ENABLE_LODEPNG |
| result = png::ConvertToPNG(buffer_info.width, buffer_info.height, |
| buffer_info.values, &out_buf); |
| #else // AMBER_ENABLE_LODEPNG |
| result = amber::Result("PNG support not enabled"); |
| #endif // AMBER_ENABLE_LODEPNG |
| } else { |
| ppm::ConvertToPPM(buffer_info.width, buffer_info.height, |
| buffer_info.values, &out_buf); |
| result = {}; |
| } |
| break; |
| } |
| } |
| if (result.IsSuccess()) { |
| std::ofstream image_file; |
| image_file.open(image_filename, std::ios::out | std::ios::binary); |
| if (!image_file.is_open()) { |
| std::cerr << "Cannot open file for image dump: "; |
| std::cerr << image_filename << std::endl; |
| continue; |
| } |
| image_file << std::string(out_buf.begin(), out_buf.end()); |
| image_file.close(); |
| } else { |
| std::cerr << result.Error() << std::endl; |
| } |
| } |
| |
| if (!options.buffer_filename.empty()) { |
| std::ofstream buffer_file; |
| buffer_file.open(options.buffer_filename, std::ios::out); |
| if (!buffer_file.is_open()) { |
| std::cerr << "Cannot open file for buffer dump: "; |
| std::cerr << options.buffer_filename << std::endl; |
| } else { |
| for (const amber::BufferInfo& buffer_info : amber_options.extractions) { |
| // Skip frame buffers. |
| if (std::any_of(options.fb_names.begin(), options.fb_names.end(), |
| [&](std::string s) { |
| return s == buffer_info.buffer_name; |
| }) || |
| buffer_info.buffer_name == kGeneratedColorBuffer) { |
| continue; |
| } |
| |
| buffer_file << buffer_info.buffer_name << std::endl; |
| const auto& values = buffer_info.values; |
| for (size_t i = 0; i < values.size(); ++i) { |
| buffer_file << " " << std::setfill('0') << std::setw(2) << std::hex |
| << values[i].AsUint32(); |
| if (i % 16 == 15) |
| buffer_file << std::endl; |
| } |
| buffer_file << std::endl; |
| } |
| buffer_file.close(); |
| } |
| } |
| } |
| |
| if (!options.quiet) { |
| if (!failures.empty()) { |
| std::cout << "\nSummary of Failures:" << std::endl; |
| |
| for (const auto& failure : failures) |
| std::cout << " " << failure << std::endl; |
| } |
| |
| std::cout << "\nSummary: " |
| << (options.input_filenames.size() - failures.size()) << " pass, " |
| << failures.size() << " fail" << std::endl; |
| } |
| |
| return !failures.empty(); |
| } |