This is an automated email from the ASF dual-hosted git repository. chhsiao pushed a commit to branch 1.5.x in repository https://gitbox.apache.org/repos/asf/mesos.git
commit 6c0d92b5826205481be133e8f054f184b2cbb4cc Author: Chun-Hung Hsiao <[email protected]> AuthorDate: Mon Apr 22 15:46:36 2019 -0700 Do not implicitly decline speculatively converted resources. Currently if a framework accepts an offer with a `RESERVE` operation without a task consuming the reserved resources, the resources will be implicitly declined. This is counter to what one would expect (that only the remaining resources in the offer will be declined): Offer `cpus:10` -> `ACCEPT` with `RESERVE cpus(role):1` *Actual* implicit decline: `cpus:9;cpus(role):1` *Expected* implicit decline: `cpus:9` The same issue is present with other transformational operations (i.e., `UNRESERVE`, `CREATE` and `DESTROY`). This patch fixes this issue by only implicitly declining the "remaining" untransformed resources, computed as follows: Offered = `cpus:10` Remaining = `cpus:9;cpus(role):1` Implicitly declined = remaining - (remaining - offered) = `cpus:9;cpus(role):1` - `cpus:(role):1` = `cpus:9` Review: https://reviews.apache.org/r/70132 --- src/master/master.cpp | 37 +++++++++++++++++++++++++++++++------ 1 file changed, 31 insertions(+), 6 deletions(-) diff --git a/src/master/master.cpp b/src/master/master.cpp index 995ff55..42f88b6 100644 --- a/src/master/master.cpp +++ b/src/master/master.cpp @@ -5456,13 +5456,38 @@ void Master::_accept( conversions); } - if (!_offeredResources.empty()) { - // Tell the allocator about the unused (e.g., refused) resources. + // We now need to compute the amounts of remaining (1) speculatively converted + // resources to recover without a filter and (2) resources that are implicitly + // declined with the filter: + // + // Speculatively converted resources + // = (offered resources).apply(speculative operations) + // - resources consumed by non-speculative operations + // - offered resources not consumed by any operation + // = `_offeredResources` - offered resources not consumed by any operation + // = `_offeredResources` - offered resources + // + // (The last equality holds because resource subtraction yields no negatives.) + // + // Implicitly declined resources + // = (offered resources).apply(speculative operations) + // - resources consumed by non-speculative operations + // - speculatively converted resources + // = `_offeredResources` - speculatively converted resources + Resources speculativelyConverted = _offeredResources - offeredResources; + Resources implicitlyDeclined = _offeredResources - speculativelyConverted; + + // Tell the allocator about the net speculatively converted resources. These + // resources should not be implicitly declined. + if (!speculativelyConverted.empty()) { allocator->recoverResources( - frameworkId, - slaveId, - _offeredResources, - accept.filters()); + frameworkId, slaveId, speculativelyConverted, None()); + } + + // Tell the allocator about the implicitly declined resources. + if (!implicitlyDeclined.empty()) { + allocator->recoverResources( + frameworkId, slaveId, implicitlyDeclined, accept.filters()); } }
