lkml.org 
[lkml]   [2013]   [Aug]   [8]   [last100]   RSS Feed
Views: [wrap][no wrap]   [headers]  [forward] 
 
Messages in this thread
/
Date
From
SubjectRe: [RFC PATCH 00/12] KVM: MMU: locklessly wirte-protect
Il 06/08/2013 15:16, Xiao Guangrong ha scritto:
> Hi Gleb, Paolo, Marcelo, Takuya,
>
> Any comments or further comments? :)

It's not the easiest patch to review. I've looked at it (beyond the
small comments I have already posted), but it will take some time to
digest it...

By the way, both I and Gleb will be on vacation next week. I will read
email, but I will not be able to apply patches or do pull requests.

Paolo

> On 07/30/2013 09:01 PM, Xiao Guangrong wrote:
>> Background
>> ==========
>> Currently, when mark memslot dirty logged or get dirty page, we need to
>> write-protect large guest memory, it is the heavy work, especially, we need to
>> hold mmu-lock which is also required by vcpu to fix its page table fault and
>> mmu-notifier when host page is being changed. In the extreme cpu / memory used
>> guest, it becomes a scalability issue.
>>
>> This patchset introduces a way to locklessly write-protect guest memory.
>>
>> Idea
>> ==========
>> There are the challenges we meet and the ideas to resolve them.
>>
>> 1) How to locklessly walk rmap?
>> The first idea we got to prevent "desc" being freed when we are walking the
>> rmap is using RCU. But when vcpu runs on shadow page mode or nested mmu mode,
>> it updates the rmap really frequently.
>>
>> So we uses SLAB_DESTROY_BY_RCU to manage "desc" instead, it allows the object
>> to be reused more quickly. We also store a "nulls" in the last "desc"
>> (desc->more) which can help us to detect whether the "desc" is moved to anther
>> rmap then we can re-walk the rmap if that happened. I learned this idea from
>> nulls-list.
>>
>> Another issue is, when a spte is deleted from the "desc", another spte in the
>> last "desc" will be moved to this position to replace the deleted one. If the
>> deleted one has been accessed and we do not access the replaced one, the
>> replaced one is missed when we do lockless walk.
>> To fix this case, we do not backward move the spte, instead, we forward move
>> the entry: when a spte is deleted, we move the entry in the first desc to that
>> position.
>>
>> 2) How to locklessly access shadow page table?
>> It is easy if the handler is in the vcpu context, in that case we can use
>> walk_shadow_page_lockless_begin() and walk_shadow_page_lockless_end() that
>> disable interrupt to stop shadow page be freed. But we are on the ioctl context
>> and the paths we are optimizing for have heavy workload, disabling interrupt is
>> not good for the system performance.
>>
>> We add a indicator into kvm struct (kvm->arch.rcu_free_shadow_page), then use
>> call_rcu() to free the shadow page if that indicator is set. Set/Clear the
>> indicator are protected by slot-lock, so it need not be atomic and does not
>> hurt the performance and the scalability.
>>
>> 3) How to locklessly write-protect guest memory?
>> Currently, there are two behaviors when we write-protect guest memory, one is
>> clearing the Writable bit on spte and the another one is dropping spte when it
>> points to large page. The former is easy we only need to atomicly clear a bit
>> but the latter is hard since we need to remove the spte from rmap. so we unify
>> these two behaviors that only make the spte readonly. Making large spte
>> readonly instead of nonpresent is also good for reducing jitter.
>>
>> And we need to pay more attention on the order of making spte writable, adding
>> spte into rmap and setting the corresponding bit on dirty bitmap since
>> kvm_vm_ioctl_get_dirty_log() write-protects the spte based on the dirty bitmap,
>> we should ensure the writable spte can be found in rmap before the dirty bitmap
>> is visible. Otherwise, we cleared the dirty bitmap and failed to write-protect
>> the page.
>>
>> Performance result
>> ====================
>> Host: CPU: Intel(R) Xeon(R) CPU X5690 @ 3.47GHz x 12
>> Mem: 36G
>>
>> The benchmark i used and will be attached:
>> a) kernbench
>> b) migrate-perf
>> it emulates guest migration
>> c) mmtest
>> it repeatedly writes the memory and measures the time and is used to
>> generate memory access in the guest which is being migrated
>> d) Qemu monitor command to implement guest live migration
>> the script can be found in migrate-perf.
>>
>>
>> 1) First, we use kernbench to benchmark the performance with non-write-protection
>> case to detect the possible regression:
>>
>> EPT enabled: Base: 84.05 After the patch: 83.53
>> EPT disabled: Base: 142.57 After the patch: 141.70
>>
>> No regression and the optimization may come from lazily drop large spte.
>>
>> 2) Benchmark the performance of get dirty page
>> (./migrate-perf -c 12 -m 3000 -t 20)
>>
>> Base: Run 20 times, Avg time:24813809 ns.
>> After the patch: Run 20 times, Avg time:8371577 ns.
>>
>> It improves +196%
>>
>> 3) There is the result of Live Migration:
>> 3.1) Less vcpus, less memory and less dirty page generated
>> (
>> Guest config: MEM_SIZE=7G VCPU_NUM=6
>> The workload in migrated guest:
>> ssh -f $CLIENT "cd ~; rm -f result; nohup /home/eric/mmtest/mmtest -m 3000 -c 30 -t 60 > result &"
>> )
>>
>> Live Migration time (ms) Benchmark (ns)
>> ----------------------------------------+-------------+---------+
>> EPT | Baseline | 21638 | 266601028 |
>> + -------------------------------+-------------+---------+
>> | After | 21110 +2.5% | 264966696 +0.6% |
>> ----------------------------------------+-------------+---------+
>> Shadow | Baseline | 22542 | 271969284 | |
>> +----------+---------------------+-------------+---------+
>> | After | 21641 +4.1% | 270485511 +0.5% |
>> -------+----------+---------------------------------------------+
>>
>> 3.2) More vcpus, more memory and less dirty page generated
>> (
>> Guest config: MEM_SIZE=25G VCPU_NUM=12
>> The workload in migrated guest:
>> ssh -f $CLIENT "cd ~; rm -f result; nohup /home/eric/mmtest/mmtest -m 15000 -c 30 -t 30 > result &"
>> )
>>
>> Live Migration time (ms) Benchmark (ns)
>> ----------------------------------------+-------------+---------+
>> EPT | Baseline | 72773 | 1278228350 |
>> + -------------------------------+-------------+---------+
>> | After | 70516 +3.2% | 1266581587 +0.9% |
>> ----------------------------------------+-------------+---------+
>> Shadow | Baseline | 74198 | 1323180090 | |
>> +----------+---------------------+-------------+---------+
>> | After | 64948 +14.2% | 1299283302 +1.8% |
>> -------+----------+---------------------------------------------+
>>
>> 3.3) Less vcpus, more memory and huge dirty page generated
>> (
>> Guest config: MEM_SIZE=25G VCPU_NUM=6
>> The workload in migrated guest:
>> ssh -f $CLIENT "cd ~; rm -f result; nohup /home/eric/mmtest/mmtest -m 15000 -c 30 -t 200 > result &"
>> )
>>
>> Live Migration time (ms) Benchmark (ns)
>> ----------------------------------------+-------------+---------+
>> EPT | Baseline | 267473 | 1224657502 |
>> + -------------------------------+-------------+---------+
>> | After | 267374 +0.03% | 1221520513 +0.6% |
>> ----------------------------------------+-------------+---------+
>> Shadow | Baseline | 369999 | 1712004428 | |
>> +----------+---------------------+-------------+---------+
>> | After | 335737 +10.2% | 1556065063 +10.2% |
>> -------+----------+---------------------------------------------+
>>
>> For the case of 3.3), EPT gets small benefit, the reason is only the first
>> time guest writes memory need take mmu-lock to mark spte from nonpresent to
>> present. Other writes cost lots of time to trigger the page fault due to
>> write-protection which are fixed by fast page fault which need not take
>> mmu-lock.
>>
>> Xiao Guangrong (12):
>> KVM: MMU: remove unused parameter
>> KVM: MMU: properly check last spte in fast_page_fault()
>> KVM: MMU: lazily drop large spte
>> KVM: MMU: log dirty page after marking spte writable
>> KVM: MMU: add spte into rmap before logging dirty page
>> KVM: MMU: flush tlb if the spte can be locklessly modified
>> KVM: MMU: redesign the algorithm of pte_list
>> KVM: MMU: introduce nulls desc
>> KVM: MMU: introduce pte-list lockless walker
>> KVM: MMU: allow locklessly access shadow page table out of vcpu thread
>> KVM: MMU: locklessly write-protect the page
>> KVM: MMU: clean up spte_write_protect
>>
>> arch/x86/include/asm/kvm_host.h | 10 +-
>> arch/x86/kvm/mmu.c | 442 ++++++++++++++++++++++++++++------------
>> arch/x86/kvm/mmu.h | 28 +++
>> arch/x86/kvm/x86.c | 19 +-
>> 4 files changed, 356 insertions(+), 143 deletions(-)
>>
>
> --
> To unsubscribe from this list: send the line "unsubscribe kvm" in
> the body of a message to majordomo@vger.kernel.org
> More majordomo info at http://vger.kernel.org/majordomo-info.html
>



\
 
 \ /
  Last update: 2013-08-08 20:21    [W:0.309 / U:0.260 seconds]
©2003-2020 Jasper Spaans|hosted at Digital Ocean and TransIP|Read the blog|Advertise on this site