KVM: optimize ISR lookups

We perform ISR lookups twice: during interrupt
injection and on EOI. Typical workloads only have
a single bit set there. So we can avoid ISR scans by
1. counting bits as we set/clear them in ISR
2. on set, caching the injected vector number
3. on clear, invalidating the cache

The real purpose of this is enabling PV EOI
which needs to quickly validate the vector.
But non PV guests also benefit: with this patch,
and without interrupt nesting, apic_find_highest_isr
will always return immediately without scanning ISR.

Signed-off-by: Michael S. Tsirkin <mst@redhat.com>
Signed-off-by: Avi Kivity <avi@redhat.com>

diff --git a/arch/x86/kvm/lapic.c b/arch/x86/kvm/lapic.c
index 93c15743f1ee155bc5ebd96a3be3aaca2a300e93..805d887784f604b6bdb273e4790cfaa6b2bd89fe 100644 (file)
--- a/arch/x86/kvm/lapic.c
+++ b/arch/x86/kvm/lapic.c
@@ -107,6 +107,16 @@ static inline void apic_clear_vector(int vec, void *bitmap)
        clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
 }
 
+static inline int __apic_test_and_set_vector(int vec, void *bitmap)
+{
+       return __test_and_set_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
+static inline int __apic_test_and_clear_vector(int vec, void *bitmap)
+{
+       return __test_and_clear_bit(VEC_POS(vec), (bitmap) + REG_POS(vec));
+}
+
 static inline int apic_hw_enabled(struct kvm_lapic *apic)
 {
        return (apic)->vcpu->arch.apic_base & MSR_IA32_APICBASE_ENABLE;
@@ -210,6 +220,16 @@ static int find_highest_vector(void *bitmap)
                return fls(word[word_offset << 2]) - 1 + (word_offset << 5);
 }
 
+static u8 count_vectors(void *bitmap)
+{
+       u32 *word = bitmap;
+       int word_offset;
+       u8 count = 0;
+       for (word_offset = 0; word_offset < MAX_APIC_VECTOR >> 5; ++word_offset)
+               count += hweight32(word[word_offset << 2]);
+       return count;
+}
+
 static inline int apic_test_and_set_irr(int vec, struct kvm_lapic *apic)
 {
        apic->irr_pending = true;
@@ -242,6 +262,27 @@ static inline void apic_clear_irr(int vec, struct kvm_lapic *apic)
                apic->irr_pending = true;
 }
 
+static inline void apic_set_isr(int vec, struct kvm_lapic *apic)
+{
+       if (!__apic_test_and_set_vector(vec, apic->regs + APIC_ISR))
+               ++apic->isr_count;
+       BUG_ON(apic->isr_count > MAX_APIC_VECTOR);
+       /*
+        * ISR (in service register) bit is set when injecting an interrupt.
+        * The highest vector is injected. Thus the latest bit set matches
+        * the highest bit in ISR.
+        */
+       apic->highest_isr_cache = vec;
+}
+
+static inline void apic_clear_isr(int vec, struct kvm_lapic *apic)
+{
+       if (__apic_test_and_clear_vector(vec, apic->regs + APIC_ISR))
+               --apic->isr_count;
+       BUG_ON(apic->isr_count < 0);
+       apic->highest_isr_cache = -1;
+}
+
 int kvm_lapic_find_highest_irr(struct kvm_vcpu *vcpu)
 {
        struct kvm_lapic *apic = vcpu->arch.apic;
@@ -273,6 +314,10 @@ int kvm_apic_set_irq(struct kvm_vcpu *vcpu, struct kvm_lapic_irq *irq)
 static inline int apic_find_highest_isr(struct kvm_lapic *apic)
 {
        int result;
+       if (!apic->isr_count)
+               return -1;
+       if (likely(apic->highest_isr_cache != -1))
+               return apic->highest_isr_cache;
 
        result = find_highest_vector(apic->regs + APIC_ISR);
        ASSERT(result == -1 || result >= 16);
@@ -492,7 +537,7 @@ static void apic_set_eoi(struct kvm_lapic *apic)
        if (vector == -1)
                return;
 
-       apic_clear_vector(vector, apic->regs + APIC_ISR);
+       apic_clear_isr(vector, apic);
        apic_update_ppr(apic);
 
        if (!(apic_get_reg(apic, APIC_SPIV) & APIC_SPIV_DIRECTED_EOI) &&
@@ -1081,6 +1126,8 @@ void kvm_lapic_reset(struct kvm_vcpu *vcpu)
                apic_set_reg(apic, APIC_TMR + 0x10 * i, 0);
        }
        apic->irr_pending = false;
+       apic->isr_count = 0;
+       apic->highest_isr_cache = -1;
        update_divide_count(apic);
        atomic_set(&apic->lapic_timer.pending, 0);
        if (kvm_vcpu_is_bsp(vcpu))
@@ -1248,7 +1295,7 @@ int kvm_get_apic_interrupt(struct kvm_vcpu *vcpu)
        if (vector == -1)
                return -1;
 
-       apic_set_vector(vector, apic->regs + APIC_ISR);
+       apic_set_isr(vector, apic);
        apic_update_ppr(apic);
        apic_clear_irr(vector, apic);
        return vector;
@@ -1267,6 +1314,8 @@ void kvm_apic_post_state_restore(struct kvm_vcpu *vcpu)
        update_divide_count(apic);
        start_apic_timer(apic);
        apic->irr_pending = true;
+       apic->isr_count = count_vectors(apic->regs + APIC_ISR);
+       apic->highest_isr_cache = -1;
        kvm_make_request(KVM_REQ_EVENT, vcpu);
 }
 

diff --git a/arch/x86/kvm/lapic.h b/arch/x86/kvm/lapic.h
index d29da25ea525f4bc22e6620d553c7400363aa058..5ac9e5e2fedd181f5607d60ab7286c141766f5da 100644 (file)
--- a/arch/x86/kvm/lapic.h
+++ b/arch/x86/kvm/lapic.h
@@ -13,6 +13,10 @@ struct kvm_lapic {
        u32 divide_count;
        struct kvm_vcpu *vcpu;
        bool irr_pending;
+       /* Number of bits set in ISR. */
+       s16 isr_count;
+       /* The highest vector set in ISR; if -1 - invalid, must scan ISR. */
+       int highest_isr_cache;
        /**
         * APIC register page.  The layout matches the register layout seen by
         * the guest 1:1, because it is accessed by the vmx microcode.