iframe-proxy | Sunbelt Computer Software

793 lines (670 loc) · 25.5 KB
 * Copyright (c) 2017-2021, 2023-2026 Arm Limited.
 * SPDX-License-Identifier: MIT
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to
 * deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 * sell copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
#include "Framework.h"
#include "arm_compute/runtime/Scheduler.h"
#include "tests/framework/instruments/OpenCLMemoryUsage.h"
#include "tests/framework/instruments/OpenCLTimer.h"
#include "tests/framework/ParametersLibrary.h"
#include "tests/framework/TestFilter.h"
#ifdef ARM_COMPUTE_CL
#include "arm_compute/runtime/CL/CLRuntimeContext.h"
#include "arm_compute/runtime/CL/CLScheduler.h"
#endif /* ARM_COMPUTE_CL */
#include <chrono>
#include <iostream>
#include <memory>
#include <sstream>
#include <type_traits>
namespace arm_compute
namespace test
std::unique_ptr<ParametersLibrary> parameters;
namespace framework
std::unique_ptr<InstrumentsInfo> instruments_info;
Framework::Framework() : _test_filter(nullptr)
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::NONE),
        Instrument::make_instrument<WallClockTimestamps, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::TIME_MS),
        Instrument::make_instrument<WallClockTimestamps, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMESTAMPS, ScaleFactor::TIME_S),
        Instrument::make_instrument<WallClockTimestamps, ScaleFactor::TIME_S>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::NONE),
        Instrument::make_instrument<WallClockTimer, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::TIME_MS),
        Instrument::make_instrument<WallClockTimer, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::WALL_CLOCK_TIMER, ScaleFactor::TIME_S),
        Instrument::make_instrument<WallClockTimer, ScaleFactor::TIME_S>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::NONE),
        Instrument::make_instrument<SchedulerTimestamps, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::TIME_MS),
        Instrument::make_instrument<SchedulerTimestamps, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMESTAMPS, ScaleFactor::TIME_S),
        Instrument::make_instrument<SchedulerTimestamps, ScaleFactor::TIME_S>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::NONE),
        Instrument::make_instrument<SchedulerTimer, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::TIME_MS),
        Instrument::make_instrument<SchedulerTimer, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::SCHEDULER_TIMER, ScaleFactor::TIME_S),
        Instrument::make_instrument<SchedulerTimer, ScaleFactor::TIME_S>);
#ifdef PMU_ENABLED
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::NONE),
                                   Instrument::make_instrument<PMUCounter, ScaleFactor::NONE>);
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::SCALE_1K),
                                   Instrument::make_instrument<PMUCounter, ScaleFactor::SCALE_1K>);
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::PMU, ScaleFactor::SCALE_1M),
                                   Instrument::make_instrument<PMUCounter, ScaleFactor::SCALE_1M>);
#endif /* PMU_ENABLED */
#ifdef MALI_ENABLED
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::NONE),
                                   Instrument::make_instrument<MaliCounter, ScaleFactor::NONE>);
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::SCALE_1K),
                                   Instrument::make_instrument<MaliCounter, ScaleFactor::SCALE_1K>);
    _available_instruments.emplace(std::pair<InstrumentType, ScaleFactor>(InstrumentType::MALI, ScaleFactor::SCALE_1M),
                                   Instrument::make_instrument<MaliCounter, ScaleFactor::SCALE_1M>);
#endif /* MALI_ENABLED */
#ifdef ARM_COMPUTE_CL
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::NONE),
        Instrument::make_instrument<OpenCLTimestamps, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_US),
        Instrument::make_instrument<OpenCLTimestamps, ScaleFactor::TIME_US>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_MS),
        Instrument::make_instrument<OpenCLTimestamps, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMESTAMPS, ScaleFactor::TIME_S),
        Instrument::make_instrument<OpenCLTimestamps, ScaleFactor::TIME_S>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::NONE),
        Instrument::make_instrument<OpenCLTimer, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_US),
        Instrument::make_instrument<OpenCLTimer, ScaleFactor::TIME_US>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_MS),
        Instrument::make_instrument<OpenCLTimer, ScaleFactor::TIME_MS>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_TIMER, ScaleFactor::TIME_S),
        Instrument::make_instrument<OpenCLTimer, ScaleFactor::TIME_S>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::NONE),
        Instrument::make_instrument<OpenCLMemoryUsage, ScaleFactor::NONE>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::SCALE_1K),
        Instrument::make_instrument<OpenCLMemoryUsage, ScaleFactor::SCALE_1K>);
    _available_instruments.emplace(
        std::pair<InstrumentType, ScaleFactor>(InstrumentType::OPENCL_MEMORY_USAGE, ScaleFactor::SCALE_1M),
        Instrument::make_instrument<OpenCLMemoryUsage, ScaleFactor::SCALE_1M>);
#endif /* ARM_COMPUTE_CL */
    instruments_info = std::make_unique<InstrumentsInfo>();
std::set<InstrumentsDescription> Framework::available_instruments() const
    std::set<InstrumentsDescription> types;
    for (const auto &instrument : _available_instruments)
        types.emplace(instrument.first);
    return types;
std::map<TestResult::Status, int> Framework::count_test_results() const
    std::map<TestResult::Status, int> counts;
    for (const auto &test : _test_results)
        ++counts[test.second.status];
    return counts;
Framework &Framework::get()
    static Framework instance;
    return instance;
void Framework::init(const FrameworkConfig &config)
    _test_filter.reset(new TestFilter(config.mode, config.name_filter, config.id_filter));
    _num_iterations   = config.num_iterations;
    _log_level        = config.log_level;
    _cooldown_sec     = config.cooldown_sec;
    _configure_only   = config.configure_only;
    _print_rerun_cmd  = config.print_rerun_cmd;
    _seed             = config.seed;
    _print_iterations = config.print_iterations;
    _instruments =
        std::set<framework::InstrumentsDescription>(std::begin(config.instruments), std::end(config.instruments));
std::string Framework::current_suite_name() const
    return join(_test_suite_name.cbegin(), _test_suite_name.cend(), "/");
void Framework::push_suite(std::string name)
    _test_suite_name.emplace_back(std::move(name));
void Framework::pop_suite()
    _test_suite_name.pop_back();
void Framework::add_test_info(std::string info)
    _test_info.emplace_back(std::move(info));
void Framework::clear_test_info()
    _test_info.clear();
bool Framework::has_test_info() const
    return !_test_info.empty();
void Framework::print_test_info(std::ostream &os) const
    if (!_test_info.empty())
        os << "CONTEXT:\n";
        for (const auto &str : _test_info)
            os << "    " << str << "\n";
void Framework::add_test_warning(std::string warning)
    _test_warning.emplace_back(std::move(warning));
void Framework::clear_test_warning()
    _test_warning.clear();
bool Framework::has_test_warning() const
    return !_test_warning.empty();
void Framework::print_test_warning(std::ostream &os) const
    if (!_test_warning.empty())
        os << "CONTEXT:\n";
        for (const auto &str : _test_warning)
            os << "    " << str << "\n";
template <typename F>
void Framework::func_on_all_printers(F &&func)
    std::for_each(std::begin(_printers), std::end(_printers), func);
void Framework::log_test_start(const TestInfo &info)
    if (_log_level >= LogLevel::TESTS)
        func_on_all_printers([&](Printer *p) { p->print_test_header(info); });
void Framework::log_test_skipped(const TestInfo &info)
    static_cast<void>(info);
void Framework::log_test_end(const TestInfo &info)
    if (_log_level >= LogLevel::MEASUREMENTS)
        func_on_all_printers(
            [&](Printer *p)
                p->print_profiler_header(_test_results.at(info).header_data);
                p->print_measurements(_test_results.at(info).measurements);
    if (_log_level >= LogLevel::TESTS)
        func_on_all_printers([](Printer *p) { p->print_test_footer(); });
void Framework::log_failed_expectation(const TestError &error)
    ARM_COMPUTE_ERROR_ON(_current_test_info == nullptr);
    ARM_COMPUTE_ERROR_ON(_current_test_result == nullptr);
    const bool is_expected_failure = _current_test_info->status == TestCaseFactory::Status::EXPECTED_FAILURE;
    if (_log_level >= error.level())
        func_on_all_printers([&](Printer *p) { p->print_error(error, is_expected_failure); });
    _current_test_result->status = TestResult::Status::FAILED;
void Framework::log_info(const std::string &info)
    if (_log_level >= LogLevel::DEBUG)
        func_on_all_printers([&](Printer *p) { p->print_info(info); });
void Framework::log_warning(const std::string &warning)
    if (_log_level >= LogLevel::WARNINGS)
        func_on_all_printers([&](Printer *p) { p->print_warning(warning); });
int Framework::num_iterations() const
    return _num_iterations;
void Framework::set_num_iterations(int num_iterations)
    _num_iterations = num_iterations;
void Framework::set_throw_errors(bool throw_errors)
    _throw_errors = throw_errors;
bool Framework::throw_errors() const
    return _throw_errors;
void Framework::set_stop_on_error(bool stop_on_error)
    _stop_on_error = stop_on_error;
bool Framework::stop_on_error() const
    return _stop_on_error;
void Framework::set_error_on_missing_assets(bool error_on_missing_assets)
    _error_on_missing_assets = error_on_missing_assets;
bool Framework::error_on_missing_assets() const
    return _error_on_missing_assets;
TestResult::Status Framework::run_test(const TestInfo &info, TestCaseFactory &test_factory)
    if (test_factory.status() == TestCaseFactory::Status::DISABLED)
        log_test_skipped(info);
        set_test_result(info, TestResult(TestResult::Status::DISABLED));
        return TestResult::Status::DISABLED;
    log_test_start(info);
    Profiler   profiler = get_profiler();
    TestResult result(TestResult::Status::NOT_RUN);
    _current_test_info   = &info;
    _current_test_result = &result;
    if (_log_level >= LogLevel::ERRORS)
        func_on_all_printers([](Printer *p) { p->print_errors_header(); });
    const bool is_expected_failure = info.status == TestCaseFactory::Status::EXPECTED_FAILURE;
        std::unique_ptr<TestCase> test_case = test_factory.make();
        try
            profiler.test_start();
            test_case->do_setup();
            for (int i = 0; i < _num_iterations; ++i)
                //Start the profiler if:
                //- there is only one iteration
                //- it's not the first iteration of a multi-iterations run.
                //Reason: if the CLTuner is enabled then the first run will be really messy
                //as each kernel will be executed several times, messing up the instruments like OpenCL timers.
                if (_num_iterations == 1 || i != 0)
                    profiler.start();
                if (_prepare_function != nullptr)
                    _prepare_function();
                test_case->do_run();
                test_case->do_sync();
                if (_num_iterations == 1 || i != 0)
                    profiler.stop(_print_iterations ? i : -1);
            test_case->do_teardown();
            profiler.test_stop();
            // Change status to success if no error has happend
            if (result.status == TestResult::Status::NOT_RUN)
                result.status = TestResult::Status::SUCCESS;
        catch (const FileNotFound &error)
            profiler.test_stop();
            if (_error_on_missing_assets)
                if (_log_level >= LogLevel::ERRORS)
                    TestError test_error(error.what(), LogLevel::ERRORS);
                    func_on_all_printers([&](Printer *p) { p->print_error(test_error, is_expected_failure); });
                result.status = TestResult::Status::FAILED;
                if (_throw_errors)
                    throw;
            else
                if (_log_level >= LogLevel::DEBUG)
                    func_on_all_printers([&](Printer *p) { p->print_info(error.what()); });
                result.status = TestResult::Status::NOT_RUN;
        catch (const TestError &error)
            profiler.test_stop();
            if (_log_level >= error.level())
                func_on_all_printers([&](Printer *p) { p->print_error(error, is_expected_failure); });
            result.status = TestResult::Status::FAILED;
            if (_throw_errors)
                throw;
#ifdef ARM_COMPUTE_CL
        catch (const ::cl::Error &error)
            profiler.test_stop();
            if (_log_level >= LogLevel::ERRORS)
                std::stringstream stream;
                stream << "Error code: " << error.err();
                TestError test_error(error.what(), LogLevel::ERRORS, stream.str());
                func_on_all_printers([&](Printer *p) { p->print_error(test_error, is_expected_failure); });
            result.status = TestResult::Status::FAILED;
            if (_throw_errors)
                throw;
#endif /* ARM_COMPUTE_CL */
        catch (const std::exception &error)
            profiler.test_stop();
            if (_log_level >= LogLevel::ERRORS)
                func_on_all_printers([&](Printer *p) { p->print_error(error, is_expected_failure); });
            result.status = TestResult::Status::CRASHED;
            if (_throw_errors)
                throw;
        catch (...)
            profiler.test_stop();
            if (_log_level >= LogLevel::ERRORS)
                func_on_all_printers([&](Printer *p)
                                     { p->print_error(TestError("Received unknown exception"), is_expected_failure); });
            result.status = TestResult::Status::CRASHED;
            if (_throw_errors)
                throw;
    catch (const std::exception &error)
        if (_log_level >= LogLevel::ERRORS)
            func_on_all_printers([&](Printer *p) { p->print_error(error, is_expected_failure); });
        result.status = TestResult::Status::CRASHED;
        if (_throw_errors)
            throw;
    catch (...)
        if (_log_level >= LogLevel::ERRORS)
            func_on_all_printers([&](Printer *p)
                                 { p->print_error(TestError("Received unknown exception"), is_expected_failure); });
        result.status = TestResult::Status::CRASHED;
        if (_throw_errors)
            throw;
    if (_log_level >= LogLevel::ERRORS)
        func_on_all_printers([](Printer *p) { p->print_errors_footer(); });
    _current_test_info   = nullptr;
    _current_test_result = nullptr;
    if (result.status == TestResult::Status::FAILED)
        if (info.status == TestCaseFactory::Status::EXPECTED_FAILURE)
            result.status = TestResult::Status::EXPECTED_FAILURE;
    if (result.status == TestResult::Status::FAILED || result.status == TestResult::Status::CRASHED)
        if (_stop_on_error)
            throw std::runtime_error("Abandon on first error.");
    result.header_data  = profiler.header();
    result.measurements = profiler.measurements();
    set_test_result(info, result);
    log_test_end(info);
    return result.status;
bool Framework::run()
    // Clear old test results
    _test_results.clear();
    if (_log_level >= LogLevel::TESTS)
        func_on_all_printers([](Printer *p) { p->print_run_header(); });
    const std::chrono::time_point<std::chrono::high_resolution_clock> start = std::chrono::high_resolution_clock::now();
    int id          = 0;
    int id_run_test = 0;
    ARM_COMPUTE_UNUSED(id_run_test); // Not used if ARM_COMPUTE_CL is not defined
    for (auto &test_factory : _test_factories)
        const std::string test_case_name = test_factory->name();
        const TestInfo    test_info{id, test_case_name, test_factory->mode(), test_factory->status()};
        if (_test_filter->is_selected(test_info))
#ifdef ARM_COMPUTE_CL
            // Every 100 tests, reset the OpenCL context to release the allocated memory
            if (opencl_is_available() && (id_run_test % 100) == 0)
                auto ctx_properties   = CLScheduler::get().context().getInfo<CL_CONTEXT_PROPERTIES>(nullptr);
                auto queue_properties = CLScheduler::get().queue().getInfo<CL_QUEUE_PROPERTIES>(nullptr);
                cl::Context      new_ctx = cl::Context(CL_DEVICE_TYPE_DEFAULT, ctx_properties.data());
                cl::CommandQueue new_queue =
                    cl::CommandQueue(new_ctx, CLKernelLibrary::get().get_device(), queue_properties);
                CLKernelLibrary::get().clear_programs_cache();
                CLScheduler::get().set_context(new_ctx);
                CLScheduler::get().set_queue(new_queue);
#endif // ARM_COMPUTE_CL
            TestResult::Status result = run_test(test_info, *test_factory);
            if ((_print_rerun_cmd) && (result == TestResult::Status::CRASHED || result == TestResult::Status::FAILED))
                std::cout << "Rerun command: ./arm_compute_validation --filter='^" << test_info.name
                          << "$' --seed=" << _seed << std::endl;
            ++id_run_test;
            // Run test delay
            sleep_in_seconds(_cooldown_sec);
        ++id;
    const std::chrono::time_point<std::chrono::high_resolution_clock> end = std::chrono::high_resolution_clock::now();
    if (_log_level >= LogLevel::TESTS)
        func_on_all_printers([](Printer *p) { p->print_run_footer(); });
    auto                              runtime = std::chrono::duration_cast<std::chrono::seconds>(end - start);
    std::map<TestResult::Status, int> results = count_test_results();
    if (_log_level > LogLevel::NONE)
        std::cout << "Executed " << _test_results.size() << " test(s) (" << results[TestResult::Status::SUCCESS]
                  << " passed, " << results[TestResult::Status::EXPECTED_FAILURE] << " expected failures, "
                  << results[TestResult::Status::FAILED] << " failed, " << results[TestResult::Status::CRASHED]
                  << " crashed, " << results[TestResult::Status::DISABLED] << " disabled) in " << runtime.count()
                  << " second(s)\n";
    int num_successful_tests = results[TestResult::Status::SUCCESS] + results[TestResult::Status::EXPECTED_FAILURE] +
                               results[TestResult::Status::DISABLED];
    return (static_cast<unsigned int>(num_successful_tests) == _test_results.size());
void Framework::set_test_result(TestInfo info, TestResult result)
    _test_results.emplace(std::move(info), std::move(result));
void Framework::print_test_results(Printer &printer) const
    printer.print_run_header();
    for (const auto &test : _test_results)
        printer.print_test_header(test.first);
        printer.print_profiler_header(test.second.header_data);
        printer.print_measurements(test.second.measurements);
        printer.print_test_footer();
    printer.print_run_footer();
Profiler Framework::get_profiler() const
    Profiler profiler;
    const bool all_instruments =
        std::any_of(_instruments.begin(), _instruments.end(),
                    [](InstrumentsDescription type) -> bool { return type.first == InstrumentType::ALL; });
    auto is_selected = [&](InstrumentsDescription instrument) -> bool
        return std::find_if(_instruments.begin(), _instruments.end(),
                            [&](InstrumentsDescription type) -> bool
                                const auto group =
                                    static_cast<InstrumentType>(static_cast<uint64_t>(type.first) & 0xFF00);
                                return (group == instrument.first) && (instrument.second == type.second);
                            }) != _instruments.end();
    for (const auto &instrument : _available_instruments)
        if (all_instruments || is_selected(instrument.first))
            profiler.add(instrument.second());
    return profiler;
void Framework::add_printer(Printer *printer)
    _printers.push_back(printer);
std::vector<TestInfo> Framework::test_infos() const
    std::vector<TestInfo> ids;
    int id = 0;
    for (const auto &factory : _test_factories)
        const TestInfo test_info{id, factory->name(), factory->mode(), factory->status()};
        if (_test_filter->is_selected(test_info))
            ids.emplace_back(std::move(test_info));
        ++id;
    return ids;
LogLevel Framework::log_level() const
    return _log_level;
void Framework::set_instruments_info(InstrumentsInfo instr_info)
    ARM_COMPUTE_ERROR_ON(instruments_info == nullptr);
    *instruments_info = instr_info;
bool Framework::configure_only() const
    return _configure_only;
bool Framework::new_fixture_call() const
    return _new_fixture_call;
void Framework::set_new_fixture_call(bool val)
    _new_fixture_call = val;
void Framework::set_prepare_function(const Framework::PrepareFunc &foo)
    _prepare_function = foo;
void Framework::set_seed(unsigned int seed)
    _seed = seed;
unsigned int Framework::get_seed() const
    return _seed;
} // namespace framework
} // namespace test
} // namespace arm_compute
Sunbelt Computer Software

PL/B Language Development and Support

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Uh oh!

Sunbelt Computer Software

PL/B Language Development and Support

Uh oh!

FilesExpand file tree

Framework.cpp

Latest commit

History

Framework.cpp

File metadata and controls
