Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit ca114207 authored by Michael Butler's avatar Michael Butler
Browse files

Change NN canonical timings to nanoseconds -- hal 

A sibling CL to this CL changes the definition of nn::TimePoint to the
same type as std::chrono::steady_clock::time_point but has changed the
underlying duration representation to use uint64_t. That sibling CL also
renames nn::OptionalTimeoutDuration to nn::OptionalDuration, and changes
the definition to the same type as std::nanoseconds except the
underlying duration representation now uses uint64_t.

This CL makes changes to the NN HAL utility code in response to the
changes in the sibling CL.

Bug: 174297663
Test: mma
Test: NeuralNetworksTest_static
Change-Id: If44d9aefadb2c78b632ff289b5ff5a49f766525c
parent 7fae6c35

neuralnetworks/1.0/utils/include/nnapi/hal/1.0/PreparedModel.h

+3 −3
Original line number Diff line number Diff line
@@ -44,13 +44,13 @@ class PreparedModel final : public nn::IPreparedModel { 
    nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> execute(

            const nn::Request& request, nn::MeasureTiming measure,

            const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration) const override;

            const nn::OptionalDuration& loopTimeoutDuration) const override;



    nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>> executeFenced(

            const nn::Request& request, const std::vector<nn::SyncFence>& waitFor,

            nn::MeasureTiming measure, const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration,

            const nn::OptionalTimeoutDuration& timeoutDurationAfterFence) const override;

            const nn::OptionalDuration& loopTimeoutDuration,

            const nn::OptionalDuration& timeoutDurationAfterFence) const override;



    std::any getUnderlyingResource() const override;

neuralnetworks/1.0/utils/src/PreparedModel.cpp

+7 −6
Original line number Diff line number Diff line
@@ -55,7 +55,7 @@ PreparedModel::PreparedModel(PrivateConstructorTag /*tag*/, sp<V1_0::IPreparedMo 
nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> PreparedModel::execute(

        const nn::Request& request, nn::MeasureTiming /*measure*/,

        const nn::OptionalTimePoint& /*deadline*/,

        const nn::OptionalTimeoutDuration& /*loopTimeoutDuration*/) const {

        const nn::OptionalDuration& /*loopTimeoutDuration*/) const {

    // Ensure that request is ready for IPC.

    std::optional<nn::Request> maybeRequestInShared;

    const nn::Request& requestInShared = NN_TRY(hal::utils::makeExecutionFailure(
@@ -81,11 +81,12 @@ nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> Prepare 
}



nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>

PreparedModel::executeFenced(

        const nn::Request& /*request*/, const std::vector<nn::SyncFence>& /*waitFor*/,

        nn::MeasureTiming /*measure*/, const nn::OptionalTimePoint& /*deadline*/,

        const nn::OptionalTimeoutDuration& /*loopTimeoutDuration*/,

        const nn::OptionalTimeoutDuration& /*timeoutDurationAfterFence*/) const {

PreparedModel::executeFenced(const nn::Request& /*request*/,

                             const std::vector<nn::SyncFence>& /*waitFor*/,

                             nn::MeasureTiming /*measure*/,

                             const nn::OptionalTimePoint& /*deadline*/,

                             const nn::OptionalDuration& /*loopTimeoutDuration*/,

                             const nn::OptionalDuration& /*timeoutDurationAfterFence*/) const {

    return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)

           << "IPreparedModel::executeFenced is not supported on 1.0 HAL service";

}

neuralnetworks/1.2/utils/include/nnapi/hal/1.2/PreparedModel.h

+3 −3
Original line number Diff line number Diff line
@@ -45,13 +45,13 @@ class PreparedModel final : public nn::IPreparedModel { 
    nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> execute(

            const nn::Request& request, nn::MeasureTiming measure,

            const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration) const override;

            const nn::OptionalDuration& loopTimeoutDuration) const override;



    nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>> executeFenced(

            const nn::Request& request, const std::vector<nn::SyncFence>& waitFor,

            nn::MeasureTiming measure, const nn::OptionalTimePoint& deadline,

            const nn::OptionalTimeoutDuration& loopTimeoutDuration,

            const nn::OptionalTimeoutDuration& timeoutDurationAfterFence) const override;

            const nn::OptionalDuration& loopTimeoutDuration,

            const nn::OptionalDuration& timeoutDurationAfterFence) const override;



    std::any getUnderlyingResource() const override;

neuralnetworks/1.2/utils/src/Conversions.cpp

+22 −2
Original line number Diff line number Diff line
@@ -43,7 +43,9 @@ constexpr std::underlying_type_t<Type> underlyingType(Type value) { 
    return static_cast<std::underlying_type_t<Type>>(value);

}



using HalDuration = std::chrono::duration<uint64_t, std::micro>;

constexpr auto kVersion = android::nn::Version::ANDROID_Q;

constexpr uint64_t kNoTiming = std::numeric_limits<uint64_t>::max();



}  // namespace
@@ -270,7 +272,18 @@ GeneralResult<MeasureTiming> unvalidatedConvert(const hal::V1_2::MeasureTiming& 
}



GeneralResult<Timing> unvalidatedConvert(const hal::V1_2::Timing& timing) {

    return Timing{.timeOnDevice = timing.timeOnDevice, .timeInDriver = timing.timeInDriver};

    constexpr uint64_t kMaxTiming = std::chrono::floor<HalDuration>(Duration::max()).count();

    constexpr auto convertTiming = [](uint64_t halTiming) -> OptionalDuration {

        if (halTiming == kNoTiming) {

            return {};

        }

        if (halTiming > kMaxTiming) {

            return Duration::max();

        }

        return HalDuration{halTiming};

    };

    return Timing{.timeOnDevice = convertTiming(timing.timeOnDevice),

                  .timeInDriver = convertTiming(timing.timeInDriver)};

}



GeneralResult<Extension> unvalidatedConvert(const hal::V1_2::Extension& extension) {
@@ -547,7 +560,14 @@ nn::GeneralResult<MeasureTiming> unvalidatedConvert(const nn::MeasureTiming& mea 
}



nn::GeneralResult<Timing> unvalidatedConvert(const nn::Timing& timing) {

    return Timing{.timeOnDevice = timing.timeOnDevice, .timeInDriver = timing.timeInDriver};

    constexpr auto convertTiming = [](nn::OptionalDuration canonicalTiming) -> uint64_t {

        if (!canonicalTiming.has_value()) {

            return kNoTiming;

        }

        return std::chrono::ceil<HalDuration>(*canonicalTiming).count();

    };

    return Timing{.timeOnDevice = convertTiming(timing.timeOnDevice),

                  .timeInDriver = convertTiming(timing.timeInDriver)};

}



nn::GeneralResult<Extension> unvalidatedConvert(const nn::Extension& extension) {

neuralnetworks/1.2/utils/src/PreparedModel.cpp

+7 −6
Original line number Diff line number Diff line
@@ -106,7 +106,7 @@ PreparedModel::executeAsynchronously(const V1_0::Request& request, MeasureTiming 
nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> PreparedModel::execute(

        const nn::Request& request, nn::MeasureTiming measure,

        const nn::OptionalTimePoint& /*deadline*/,

        const nn::OptionalTimeoutDuration& /*loopTimeoutDuration*/) const {

        const nn::OptionalDuration& /*loopTimeoutDuration*/) const {

    // Ensure that request is ready for IPC.

    std::optional<nn::Request> maybeRequestInShared;

    const nn::Request& requestInShared = NN_TRY(hal::utils::makeExecutionFailure(
@@ -140,11 +140,12 @@ nn::ExecutionResult<std::pair<std::vector<nn::OutputShape>, nn::Timing>> Prepare 
}



nn::GeneralResult<std::pair<nn::SyncFence, nn::ExecuteFencedInfoCallback>>

PreparedModel::executeFenced(

        const nn::Request& /*request*/, const std::vector<nn::SyncFence>& /*waitFor*/,

        nn::MeasureTiming /*measure*/, const nn::OptionalTimePoint& /*deadline*/,

        const nn::OptionalTimeoutDuration& /*loopTimeoutDuration*/,

        const nn::OptionalTimeoutDuration& /*timeoutDurationAfterFence*/) const {

PreparedModel::executeFenced(const nn::Request& /*request*/,

                             const std::vector<nn::SyncFence>& /*waitFor*/,

                             nn::MeasureTiming /*measure*/,

                             const nn::OptionalTimePoint& /*deadline*/,

                             const nn::OptionalDuration& /*loopTimeoutDuration*/,

                             const nn::OptionalDuration& /*timeoutDurationAfterFence*/) const {

    return NN_ERROR(nn::ErrorStatus::GENERAL_FAILURE)

           << "IPreparedModel::executeFenced is not supported on 1.2 HAL service";

}