target/arm: Remove stale comment
PATCH 1/5 target/arm: Remove stale comment
Update the comment which is not true since MTTCG.
--- target/arm/translate-a64.c | 4 ---- 1 file changed, 4 deletions(-)
target/arm/translate-a64.c +0 -4
@@ -2012,10 +2012,6 @@ static void disas_ldst_excl(DisasContext *s, uint32_t insn) } tcg_addr =read_cpu_reg_sp (s, rn,1 ); -/* Note that since TCG is single threaded load-acquire/store-release -* semantics require no extra if (is_lasr) { ... } handling. -*/ -if (is_excl) {if (!is_store) { s->is_ldex = true;
Signature · 1 line
2.13.0
RFC PATCH v3 3/5 mttcg: Add tcg target default memory ordering
--- tcg/aarch64/tcg-target.h | 2 ++ tcg/arm/tcg-target.h | 2 ++ tcg/ia64/tcg-target.h | 2 ++ tcg/mips/tcg-target.h | 2 ++ tcg/ppc/tcg-target.h | 2 ++ tcg/s390/tcg-target.h | 2 ++ tcg/sparc/tcg-target.h | 2 ++ 7 files changed, 14 insertions(+)
tcg/aarch64/tcg-target.h +2 -0
@@ -117,4 +117,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) __builtin___clear_cache((char *)start, (char *)stop); } +#define TCG_TARGET_DEFAULT_MO (0) +#endif /* AARCH64_TCG_TARGET_H */
tcg/arm/tcg-target.h +2 -0
@@ -134,4 +134,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) __builtin___clear_cache((char *) start, (char *) stop); } +#define TCG_TARGET_DEFAULT_MO (0) +#endif
tcg/ia64/tcg-target.h +2 -0
@@ -195,4 +195,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) asm volatile (";;sync.i;;srlz.i;;"); } +#define TCG_TARGET_DEFAULT_MO (0) +#endif
tcg/mips/tcg-target.h +2 -0
@@ -206,4 +206,6 @@ static inline void flush_icache_range(uintptr_t start, uintptr_t stop) cacheflush ((void *)start, stop-start, ICACHE); } +#define TCG_TARGET_DEFAULT_MO (0) +#endif
tcg/ppc/tcg-target.h +2 -0
@@ -125,4 +125,6 @@ extern bool have_isa_3_00;void flush_icache_range (uintptr_t start,uintptr_t stop); +#define TCG_TARGET_DEFAULT_MO (0) +#endif
tcg/s390/tcg-target.h +2 -0
@@ -133,6 +133,8 @@ extern uint64_t s390_facilities;#define TCG_TARGET_EXTEND_ARGS 1 +#define TCG_TARGET_DEFAULT_MO (TCG_MO_ALL & ~TCG_MO_ST_LD) +enum {TCG_AREG0 =TCG_REG_R10 , };
tcg/sparc/tcg-target.h +2 -0
@@ -162,6 +162,8 @@ extern bool use_vis3_instructions;#define TCG_AREG0 TCG_REG_I0 +#define TCG_TARGET_DEFAULT_MO (0) +static inline void flush_icache_range (uintptr_t start,uintptr_t stop) {uintptr_t p;
Signature · 1 line
2.13.0
RFC PATCH v3 2/5 cpus-common: Cache allocated work items
In reply to Pranith KumarUsing heaptrack, I found that quite a few of our temporary allocations are coming from allocating work items. Instead of doing this continously, we can cache the allocated items and reuse them instead of freeing them.
Stats from an ARM64 guest (boot+shutdown):
heaptrack stats(before):
allocations: 1471317
leaked allocations: 73824
temporary allocations: 651293heaptrack stats(after):
allocations: 1143130
leaked allocations: 73693
temporary allocations: 487342The improvement in speedup is minor and within error margins, however I think the patch is still worth. We can also explore atomics instead of taking a lock for the work item pool.
--- cpus-common.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 60 insertions(+), 15 deletions(-)
cpus-common.c +60 -15
@@ -24,6 +24,7 @@#include "sysemu/cpus.h" static QemuMutex qemu_cpu_list_lock; +static QemuMutex qemu_wi_pool_lock;static QemuCond exclusive_cond;static QemuCond exclusive_resume;static QemuCond qemu_work_cond;
@@ -33,6 +34,49 @@ static QemuCond qemu_work_cond;*/ static int pending_cpus; +typedef struct qemu_work_item { +struct qemu_work_item *next; +run_on_cpu_func func; +run_on_cpu_data data; +bool free, exclusive, done; +}qemu_work_item ; + +typedef struct qemu_wi_pool { +qemu_work_item *head; +int num_items; +}qemu_wi_pool ; + +qemu_wi_pool *wi_free_pool; + +static void qemu_init_workitem_pool (void ) +{ + wi_free_pool =g_malloc0 (sizeof (qemu_wi_pool)); +} + +static void qemu_wi_pool_insert (qemu_work_item *item) +{ +qemu_mutex_lock (&qemu_wi_pool_lock); +qemu_work_item *curr =atomic_read (&wi_free_pool->head); + item->next = curr; + wi_free_pool->head = item; +qemu_mutex_unlock (&qemu_wi_pool_lock); +} + +static qemu_work_item *qemu_wi_pool_remove (void ) +{ +qemu_mutex_lock (&qemu_wi_pool_lock); +qemu_work_item *curr =atomic_read (&wi_free_pool->head); +if (curr ==NULL ) { + goto out; + } + wi_free_pool->head = curr->next; + curr->next =NULL ; + + out: +qemu_mutex_unlock (&qemu_wi_pool_lock); +return curr; +} +void qemu_init_cpu_list (void ) {/* This is needed because qemu_init_cpu_list is also called by the
@@ -43,6 +87,9 @@ void qemu_init_cpu_list(void)qemu_cond_init (&exclusive_cond);qemu_cond_init (&exclusive_resume);qemu_cond_init (&qemu_work_cond); + +qemu_init_workitem_pool (); +qemu_mutex_init (&qemu_wi_pool_lock); }void cpu_list_lock (void )
@@ -106,14 +153,7 @@ void cpu_list_remove(CPUState *cpu)qemu_mutex_unlock (&qemu_cpu_list_lock); } -struct qemu_work_item { -struct qemu_work_item *next; -run_on_cpu_func func; -run_on_cpu_data data; -bool free, exclusive, done; -}; - -static void queue_work_on_cpu (CPUState *cpu,struct qemu_work_item *wi) +static void queue_work_on_cpu (CPUState *cpu,qemu_work_item *wi) {qemu_mutex_lock (&cpu->work_mutex);if (cpu->queued_work_first ==NULL ) {
@@ -132,7 +172,7 @@ static void queue_work_on_cpu(CPUState *cpu, struct qemu_work_item *wi)void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data,QemuMutex *mutex) { -struct qemu_work_item wi; +qemu_work_item wi;if (qemu_cpu_is_self (cpu)) {func (cpu, data);
@@ -156,9 +196,11 @@ void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data,void async_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) { -struct qemu_work_item *wi; +qemu_work_item *wi =qemu_wi_pool_remove (); - wi =g_malloc0 (sizeof (struct qemu_work_item )); +if (!wi) { + wi =g_malloc0 (sizeof (qemu_work_item)); + } wi->func = func; wi->data = data; wi->free = true;
@@ -299,9 +341,11 @@ void cpu_exec_end(CPUState *cpu)void async_safe_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) { -struct qemu_work_item *wi; +qemu_work_item *wi =qemu_wi_pool_remove (); - wi =g_malloc0 (sizeof (struct qemu_work_item )); +if (!wi) { + wi =g_malloc0 (sizeof (qemu_work_item)); + } wi->func = func; wi->data = data; wi->free = true;
@@ -312,7 +356,7 @@ void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func,void process_queued_cpu_work (CPUState *cpu) { -struct qemu_work_item *wi; +qemu_work_item *wi;if (cpu->queued_work_first ==NULL ) {return ;
@@ -343,7 +387,8 @@ void process_queued_cpu_work(CPUState *cpu) }qemu_mutex_lock (&cpu->work_mutex);if (wi->free) { -g_free (wi); +memset (wi,0 ,sizeof (qemu_work_item)); +qemu_wi_pool_insert (wi); }else {atomic_mb_set (&wi->done, true); }
Signature · 1 line
2.13.0
RFC PATCH v3 5/5 tcg/softmmu: Increase size of TLB caches
In reply to Pranith KumarThis patch increases the number of entries cached in the TLB. I went over a few architectures to see if increasing it is problematic. Only armv6 seems to have a limitation that only 8 bits can be used for indexing these entries. For other architectures, the number of TLB entries is increased to a 4K-sized cache. The patch also doubles the number of victim TLB entries.
Some statistics collected from a build benchmark for various cache sizes is listed below:
| TLB bits\vTLB entires | 8 | 16 | 32 | | 8 | 952.94(+0.0%) | 929.99(+2.4%) | 919.02(+3.6%) | | 10 | 898.92(+5.6%) | 886.13(+7.0%) | 887.03(+6.9%) | | 12 | 878.56(+7.8%) | 873.53(+8.3%)* | 875.34(+8.1%) |
The best combination for this workload came out to be 12 bits for the TLB and a 16 entry vTLB cache.
--- include/exec/cpu-defs.h | 13 ++++--------- tcg/aarch64/tcg-target.h | 1 + tcg/arm/tcg-target.h | 1 + tcg/i386/tcg-target.h | 6 ++++++ tcg/ia64/tcg-target.h | 1 + tcg/mips/tcg-target.h | 6 ++++++ tcg/ppc/tcg-target.h | 1 + tcg/s390/tcg-target.h | 1 + tcg/sparc/tcg-target.h | 1 + tcg/tci/tcg-target.h | 2 ++ 10 files changed, 24 insertions(+), 9 deletions(-)
include/exec/cpu-defs.h +4 -9
@@ -57,8 +57,8 @@ typedef uint64_t target_ulong;#endif #if !defined(CONFIG_USER_ONLY ) && defined(CONFIG_TCG ) -/* use a fully associative victim tlb of 8 entries */ -#define CPU_VTLB_SIZE 8 +/* use a fully associative victim tlb of 16 entries */ +#define CPU_VTLB_SIZE 16#if HOST_LONG_BITS ==32 &&TARGET_LONG_BITS ==32 #define CPU_TLB_ENTRY_BITS 4
@@ -87,14 +87,9 @@ typedef uint64_t target_ulong;* could be something like 0xC000 (the offset of the last TLB table) plus * 0x18 (the offset of the addend field in each TLB entry) plus the offset * of tlb_table inside env (which is non-trivial but not huge). +* TODO: rewrite this comment */ -#define CPU_TLB_BITS \ - MIN(8, \ - TCG_TARGET_TLB_DISPLACEMENT_BITS - CPU_TLB_ENTRY_BITS - \ - (NB_MMU_MODES <= 1 ? 0 : \ - NB_MMU_MODES <= 2 ? 1 : \ - NB_MMU_MODES <= 4 ? 2 : \ - NB_MMU_MODES <= 8 ? 3 : 4)) +#define CPU_TLB_BITS MIN(12, TCG_TARGET_TLB_MAX_INDEX_BITS)#define CPU_TLB_SIZE (1 << CPU_TLB_BITS)
tcg/aarch64/tcg-target.h +1 -0
@@ -15,6 +15,7 @@#define TCG_TARGET_INSN_UNIT_SIZE 4#define TCG_TARGET_TLB_DISPLACEMENT_BITS 24 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 32#undef TCG_TARGET_STACK_GROWSUP typedef enum {
tcg/arm/tcg-target.h +1 -0
@@ -60,6 +60,7 @@ extern int arm_arch;#undef TCG_TARGET_STACK_GROWSUP#define TCG_TARGET_INSN_UNIT_SIZE 4#define TCG_TARGET_TLB_DISPLACEMENT_BITS 16 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 8 typedef enum { TCG_REG_R0 = 0,
tcg/i386/tcg-target.h +6 -0
@@ -162,6 +162,12 @@ extern bool have_popcnt;# define TCG_AREG0 TCG_REG_EBP#endif +#if HOST_LONG_BITS ==32 &&TARGET_LONG_BITS ==32 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 28 +#else +#define TCG_TARGET_TLB_MAX_INDEX_BITS 27 +#endif +static inline void flush_icache_range (uintptr_t start,uintptr_t stop) { }
tcg/ia64/tcg-target.h +1 -0
@@ -28,6 +28,7 @@#define TCG_TARGET_INSN_UNIT_SIZE 16#define TCG_TARGET_TLB_DISPLACEMENT_BITS 21 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 32 typedef struct { uint64_t lo __attribute__((aligned(16)));
tcg/mips/tcg-target.h +6 -0
@@ -39,6 +39,12 @@#define TCG_TARGET_TLB_DISPLACEMENT_BITS 16#define TCG_TARGET_NB_REGS 32 +#if HOST_LONG_BITS ==32 &&TARGET_LONG_BITS ==32 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 12 +#else +#define TCG_TARGET_TLB_MAX_INDEX_BITS 11 +#endif + typedef enum { TCG_REG_ZERO = 0, TCG_REG_AT,
tcg/ppc/tcg-target.h +1 -0
@@ -34,6 +34,7 @@#define TCG_TARGET_NB_REGS 32#define TCG_TARGET_INSN_UNIT_SIZE 4#define TCG_TARGET_TLB_DISPLACEMENT_BITS 16 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 32 typedef enum { TCG_REG_R0, TCG_REG_R1, TCG_REG_R2, TCG_REG_R3,
tcg/s390/tcg-target.h +1 -0
@@ -27,6 +27,7 @@#define TCG_TARGET_INSN_UNIT_SIZE 2#define TCG_TARGET_TLB_DISPLACEMENT_BITS 19 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 32 typedef enum TCGReg { TCG_REG_R0 = 0,
tcg/sparc/tcg-target.h +1 -0
@@ -29,6 +29,7 @@#define TCG_TARGET_INSN_UNIT_SIZE 4#define TCG_TARGET_TLB_DISPLACEMENT_BITS 32 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 12#define TCG_TARGET_NB_REGS 32 typedef enum {
tcg/tci/tcg-target.h +2 -0
@@ -40,9 +40,11 @@#ifndef TCG_TARGET_H #define TCG_TARGET_H +#define TCG_TARGET_INTERPRETER 1#define TCG_TARGET_INSN_UNIT_SIZE 1#define TCG_TARGET_TLB_DISPLACEMENT_BITS 32 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 32#if UINTPTR_MAX ==UINT32_MAX # define TCG_TARGET_REG_BITS 32
Signature · 1 line
2.13.0
RFC PATCH v3 4/5 mttcg: Implement implicit ordering semantics
In reply to Pranith KumarCurrently, we cannot use mttcg for running strong memory model guests on weak memory model hosts due to missing ordering semantics.
We implicitly generate fence instructions for stronger guests if an ordering mismatch is detected. We generate fences only for the orders for which fence instructions are necessary, for example a fence is not necessary between a store and a subsequent load on x86 since its absence in the guest binary tells that ordering need not be ensured. Also note that if we find multiple subsequent fence instructions in the generated IR, we combine them in the TCG optimization pass.
This patch allows us to boot an x86 guest on ARM64 hosts using mttcg.
--- tcg/tcg-op.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
tcg/tcg-op.c +16 -0
@@ -28,6 +28,7 @@#include "exec/exec-all.h" #include "tcg.h" #include "tcg-op.h" +#include "tcg-mo.h" #include "trace-tcg.h" #include "trace/mem.h"
@@ -2662,8 +2663,20 @@ static void gen_ldst_i64(TCGOpcode opc, TCGv_i64 val, TCGv addr,#endif } +static void tcg_gen_req_mo (TCGBar type) +{ +#ifdef TCG_GUEST_DEFAULT_MO + type &=TCG_GUEST_DEFAULT_MO ; +#endif + type &= ~TCG_TARGET_DEFAULT_MO ; +if (type) { +tcg_gen_mb (type |TCG_BAR_SC ); + } +} +void tcg_gen_qemu_ld_i32 (TCGv_i32 val,TCGv addr,TCGArg idx,TCGMemOp memop) { +tcg_gen_req_mo (TCG_MO_LD_LD |TCG_MO_ST_LD ); memop =tcg_canonicalize_memop (memop,0 ,0 );trace_guest_mem_before_tcg (tcg_ctx.cpu, tcg_ctx.tcg_env, addr,trace_mem_get_info (memop,0 ));
@@ -2672,6 +2685,7 @@ void tcg_gen_qemu_ld_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop)void tcg_gen_qemu_st_i32 (TCGv_i32 val,TCGv addr,TCGArg idx,TCGMemOp memop) { +tcg_gen_req_mo (TCG_MO_LD_ST |TCG_MO_ST_ST ); memop =tcg_canonicalize_memop (memop,0 ,1 );trace_guest_mem_before_tcg (tcg_ctx.cpu, tcg_ctx.tcg_env, addr,trace_mem_get_info (memop,1 ));
@@ -2680,6 +2694,7 @@ void tcg_gen_qemu_st_i32(TCGv_i32 val, TCGv addr, TCGArg idx, TCGMemOp memop)void tcg_gen_qemu_ld_i64 (TCGv_i64 val,TCGv addr,TCGArg idx,TCGMemOp memop) { +tcg_gen_req_mo (TCG_MO_LD_LD |TCG_MO_ST_LD );if (TCG_TARGET_REG_BITS ==32 && (memop &MO_SIZE ) <MO_64 ) {tcg_gen_qemu_ld_i32 (TCGV_LOW (val), addr, idx, memop);if (memop &MO_SIGN ) {
@@ -2698,6 +2713,7 @@ void tcg_gen_qemu_ld_i64(TCGv_i64 val, TCGv addr, TCGArg idx, TCGMemOp memop)void tcg_gen_qemu_st_i64 (TCGv_i64 val,TCGv addr,TCGArg idx,TCGMemOp memop) { +tcg_gen_req_mo (TCG_MO_LD_ST |TCG_MO_ST_ST );if (TCG_TARGET_REG_BITS ==32 && (memop &MO_SIZE ) <MO_64 ) {tcg_gen_qemu_st_i32 (TCGV_LOW (val), addr, idx, memop);return ;
Signature · 1 line
2.13.0
Re: [RFC v3 PATCH 3/5] mttcg: Add tcg target default memory ordering
In reply to Pranith KumarQuoted 10 lines · Pranith Kumar
Signed-off-by Pranith Kumar <[email protected]>--- tcg/aarch64/tcg-target.h | 2 ++ tcg/arm/tcg-target.h | 2 ++ tcg/ia64/tcg-target.h | 2 ++ tcg/mips/tcg-target.h | 2 ++ tcg/ppc/tcg-target.h | 2 ++ tcg/s390/tcg-target.h | 2 ++ tcg/sparc/tcg-target.h | 2 ++ 7 files changed, 14 insertions(+)
r~
Re: [Qemu-devel] [RFC v3 PATCH 4/5] mttcg: Implement implicit ordering semantics
In reply to Pranith KumarQuoted 12 lines · Pranith Kumar
Currently, we cannot use mttcg for running strong memory model guests on weak memory model hosts due to missing ordering semantics.
We implicitly generate fence instructions for stronger guests if an ordering mismatch is detected. We generate fences only for the orders for which fence instructions are necessary, for example a fence is not necessary between a store and a subsequent load on x86 since its absence in the guest binary tells that ordering need not be ensured. Also note that if we find multiple subsequent fence instructions in the generated IR, we combine them in the TCG optimization pass.
Quoted 6 lines
This patch allows us to boot an x86 guest on ARM64 hosts using mttcg.
Signed-off-by Pranith Kumar <[email protected]>--- tcg/tcg-op.c | 16 ++++++++++++++++ 1 file changed, 16 insertions(+)
r~
Re: [RFC v3 PATCH 5/5] tcg/softmmu: Increase size of TLB caches
In reply to Pranith Kumarinclude/exec/cpu-defs.h typedef uint64_t target_ulong; · line 92
Quoted 11 lines · Pranith Kumar
+ * TODO: rewrite this comment
*/include/exec/cpu-defs.h +1
-7-#define CPU_TLB_BITS \ - MIN(8, \ - TCG_TARGET_TLB_DISPLACEMENT_BITS - CPU_TLB_ENTRY_BITS - \ - (NB_MMU_MODES <= 1 ? 0 : \ - NB_MMU_MODES <= 2 ? 1 : \ - NB_MMU_MODES <= 4 ? 2 : \ - NB_MMU_MODES <= 8 ? 3 : 4)) +#define CPU_TLB_BITS MIN(12, TCG_TARGET_TLB_MAX_INDEX_BITS)
Ah, no. This will cause several builds to fail. You still need to restrict the *total* size of the TLB to TCG_TARGET_TLB_DISPLACEMENT_BITS.
(That's not a 100% accurate statement, but is close. See the QEMU_BUILD_BUG_ON in tcg/*/*.c for specifics.)
The upshot is that if a target has 2 MMU modes, we can allow them to be bigger. But if it has 8, we have to make them smaller.
I was expecting you to write
MIN(MIN(12, TCG_TARGET_TLB_MAX_INDEX_BITS)
TCG_TARGET_TLB_DISPLACEMENT_BITS - CPU_TLB_ENTRY_BITS - ...)
r~
Re: [RFC v3 PATCH 5/5] tcg/softmmu: Increase size of TLB caches
In reply to Pranith Kumartcg/i386/tcg-target.h extern bool have_popcnt; · line 170
Quoted 6 lines · Pranith Kumar
tcg/i386/tcg-target.h +6
-0+#if HOST_LONG_BITS ==32 &&TARGET_LONG_BITS ==32 +#define TCG_TARGET_TLB_MAX_INDEX_BITS 28 +#else +#define TCG_TARGET_TLB_MAX_INDEX_BITS 27 +#endif +
For the record, did it not work to actually write (32 - CPU_TLB_BITS)? I'm not fond of repeating the conditions that go into computing CPU_TLB_BITS.
r~
Re: [RFC v3 PATCH 5/5] tcg/softmmu: Increase size of TLB caches
In reply to Richard HendersonQuoted 24 lines · Richard Henderson
include/exec/cpu-defs.h typedef uint64_t target_ulong; · line 92
Quoted 11 lines · Pranith Kumar
+ * TODO: rewrite this comment
*/include/exec/cpu-defs.h +1
-7-#define CPU_TLB_BITS \ - MIN(8, \ - TCG_TARGET_TLB_DISPLACEMENT_BITS - CPU_TLB_ENTRY_BITS - \ - (NB_MMU_MODES <= 1 ? 0 : \ - NB_MMU_MODES <= 2 ? 1 : \ - NB_MMU_MODES <= 4 ? 2 : \ - NB_MMU_MODES <= 8 ? 3 : 4)) +#define CPU_TLB_BITS MIN(12, TCG_TARGET_TLB_MAX_INDEX_BITS)Ah, no. This will cause several builds to fail. You still need to restrict the *total* size of the TLB to
TCG_TARGET_TLB_DISPLACEMENT_BITS.(That's not a 100% accurate statement, but is close. See the
QEMU_BUILD_BUG_ONin tcg/*/*.c for specifics.)The upshot is that if a target has 2 MMU modes, we can allow them to be bigger. But if it has 8, we have to make them smaller.
Quoted 5 lines
I was expecting you to write
MIN(MIN(12,
TCG_TARGET_TLB_MAX_INDEX_BITS)
TCG_TARGET_TLB_DISPLACEMENT_BITS-CPU_TLB_ENTRY_BITS- ...)
I see what you mean. I will fix the blunder and send an updated patch.
Thanks!
Signature · 1 line
Pranith
Re: [Qemu-devel] [RFC v3 PATCH 4/5] mttcg: Implement implicit ordering semantics
In reply to Pranith KumarQuoted 4 lines · Pranith Kumar
Currently, we cannot use mttcg for running strong memory model guests on weak memory model hosts due to missing ordering semantics.
We implicitly generate fence instructions for stronger guests if an
This confused me. By "We implicitly" are we still talking about the current state (as per the "currently" above?). If not, I'd rephrase as:
"We cannot use [...].
To fix it, generate fences [...]"
Also, I think you meant s/stronger/weaker/ in the last sentence.
Quoted 7 lines
ordering mismatch is detected. We generate fences only for the orders for which fence instructions are necessary, for example a fence is not necessary between a store and a subsequent load on x86 since its absence in the guest binary tells that ordering need not be ensured. Also note that if we find multiple subsequent fence instructions in the generated IR, we combine them in the TCG optimization pass.
A before/after example of -d out_asm would be great to have here.
Quoted 2 lines
This patch allows us to boot an x86 guest on ARM64 hosts using mttcg.
A test with a simple program that *cannot* work without this patch would be even better.
Thanks,
Emilio
Quoted 1 line · Pranith Kumar
Update the comment which is not true since MTTCG.
What happened to the cover letter? We seem to have a mix of patches but no summary of the overall outcome.
Quoted 12 lines
Reviewed-by Richard Henderson <[email protected]>Signed-off-by Pranith Kumar <[email protected]>--- target/arm/translate-a64.c | 4 ---- 1 file changed, 4 deletions(-)target/arm/translate-a64.c +0
-0
target/arm/translate-a64.c static void disas_ldst_excl(DisasContext *s, uint32_t insn) · line 2017
Quoted 10 lines
target/arm/translate-a64.c +0
-4@@ -2012,10 +2012,6 @@ static void disas_ldst_excl(DisasContext *s, uint32_t insn) } tcg_addr =read_cpu_reg_sp (s, rn,1 ); -/* Note that since TCG is single threaded load-acquire/store-release -* semantics require no extra if (is_lasr) { ... } handling. -*/ -if (is_excl) {if (!is_store) { s->is_ldex = true;
--
Alex Bennée
Re: [Qemu-devel] [RFC v3 PATCH 2/5] cpus-common: Cache allocated work items
In reply to Pranith KumarQuoted 12 lines · Pranith Kumar
Using heaptrack, I found that quite a few of our temporary allocations are coming from allocating work items. Instead of doing this continously, we can cache the allocated items and reuse them instead of freeing them.
Stats from an ARM64 guest (boot+shutdown):
heaptrack stats(before):
allocations: 1471317 leaked allocations: 73824 temporary allocations: 651293
Quoted 8 lines
heaptrack stats(after):
allocations: 1143130 leaked allocations: 73693 temporary allocations: 487342The improvement in speedup is minor and within error margins, however I think the patch is still worth. We can also explore atomics instead of taking a lock for the work item pool.
When we where doing the original MTTCG work I looked at using GArray for the work queue, see:
http://lists.gnu.org/archive/html/qemu-devel/2016-08/msg00367.html
specifically:
Subject: [PATCH v5 13/13] cpu-exec: replace cpu->queued_work with GArray
Date: Tue, 2 Aug 2016 18:27:44 +0100
Message-Id: <[email protected]>
which I personally think might yield better results than messing around with custom allocators and GSlice and the like. You still get the dynamic sizing of a malloc based array but for operations like insertion and iterating through the work queue should be cache friendly.
Once the array has (transparently) reached a reasonable size to service all allocations in the usual servicing period the same memory can be used over and over again ;-)
My fondness for arrays is informed by comments by Bjarne Stroustrup:
https://www.youtube.com/watch?v=YQs6IC-vgmo
Obviously this patch would need to be re-worked given how much the code has changes since it was merged.
Quoted 141 lines
Signed-off-by Pranith Kumar <[email protected]>--- cpus-common.c | 75 +++++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 60 insertions(+), 15 deletions(-)cpus-common.c +58
-14@@ -24,6 +24,7 @@#include "sysemu/cpus.h" static QemuMutex qemu_cpu_list_lock; +static QemuMutex qemu_wi_pool_lock;static QemuCond exclusive_cond;static QemuCond exclusive_resume;static QemuCond qemu_work_cond;@@ -33,6 +34,49 @@ static QemuCond qemu_work_cond;*/ static int pending_cpus; +typedef struct qemu_work_item { +struct qemu_work_item *next; +run_on_cpu_func func; +run_on_cpu_data data; +bool free, exclusive, done; +}qemu_work_item ; + +typedef struct qemu_wi_pool { +qemu_work_item *head; +int num_items; +}qemu_wi_pool ; + +qemu_wi_pool *wi_free_pool; + +static void qemu_init_workitem_pool (void ) +{ + wi_free_pool =g_malloc0 (sizeof (qemu_wi_pool)); +} + +static void qemu_wi_pool_insert (qemu_work_item *item) +{ +qemu_mutex_lock (&qemu_wi_pool_lock); +qemu_work_item *curr =atomic_read (&wi_free_pool->head); + item->next = curr; + wi_free_pool->head = item; +qemu_mutex_unlock (&qemu_wi_pool_lock); +} + +static qemu_work_item *qemu_wi_pool_remove (void ) +{ +qemu_mutex_lock (&qemu_wi_pool_lock); +qemu_work_item *curr =atomic_read (&wi_free_pool->head); +if (curr ==NULL ) { + goto out; + } + wi_free_pool->head = curr->next; + curr->next =NULL ; + + out: +qemu_mutex_unlock (&qemu_wi_pool_lock); +return curr; +} +void qemu_init_cpu_list (void ) {/* This is needed because qemu_init_cpu_list is also called by the @@ -43,6 +87,9 @@ void qemu_init_cpu_list(void)qemu_cond_init (&exclusive_cond);qemu_cond_init (&exclusive_resume);qemu_cond_init (&qemu_work_cond); + +qemu_init_workitem_pool (); +qemu_mutex_init (&qemu_wi_pool_lock); }void cpu_list_lock (void )@@ -106,14 +153,7 @@ void cpu_list_remove(CPUState *cpu)qemu_mutex_unlock (&qemu_cpu_list_lock); } -struct qemu_work_item { -struct qemu_work_item *next; -run_on_cpu_func func; -run_on_cpu_data data; -bool free, exclusive, done; -}; - -static void queue_work_on_cpu (CPUState *cpu,struct qemu_work_item *wi) +static void queue_work_on_cpu (CPUState *cpu,qemu_work_item *wi) {qemu_mutex_lock (&cpu->work_mutex);if (cpu->queued_work_first ==NULL ) {@@ -132,7 +172,7 @@ static void queue_work_on_cpu(CPUState *cpu, struct qemu_work_item *wi)void do_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data,QemuMutex *mutex) { -struct qemu_work_item wi; +qemu_work_item wi;if (qemu_cpu_is_self (cpu)) {func (cpu, data);@@ -156,9 +196,11 @@ void do_run_on_cpu(CPUState *cpu, run_on_cpu_func func, run_on_cpu_data data,void async_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) { -struct qemu_work_item *wi; +qemu_work_item *wi =qemu_wi_pool_remove (); - wi =g_malloc0 (sizeof (struct qemu_work_item )); +if (!wi) { + wi =g_malloc0 (sizeof (qemu_work_item)); + } wi->func = func; wi->data = data; wi->free = true;@@ -299,9 +341,11 @@ void cpu_exec_end(CPUState *cpu)void async_safe_run_on_cpu (CPUState *cpu,run_on_cpu_func func,run_on_cpu_data data) { -struct qemu_work_item *wi; +qemu_work_item *wi =qemu_wi_pool_remove (); - wi =g_malloc0 (sizeof (struct qemu_work_item )); +if (!wi) { + wi =g_malloc0 (sizeof (qemu_work_item)); + } wi->func = func; wi->data = data; wi->free = true;@@ -312,7 +356,7 @@ void async_safe_run_on_cpu(CPUState *cpu, run_on_cpu_func func,void process_queued_cpu_work (CPUState *cpu) { -struct qemu_work_item *wi; +qemu_work_item *wi;if (cpu->queued_work_first ==NULL ) {return ;
cpus-common.c void process_queued_cpu_work(CPUState *cpu) · line 394
Quoted 9 lines
cpus-common.c +2
-1@@ -343,7 +387,8 @@ void process_queued_cpu_work(CPUState *cpu) }qemu_mutex_lock (&cpu->work_mutex);if (wi->free) { -g_free (wi); +memset (wi,0 ,sizeof (qemu_work_item)); +qemu_wi_pool_insert (wi); }else {atomic_mb_set (&wi->done, true); }
--
Alex Bennée
Hi Alex,
Quoted 8 lines · Alex Bennée
Quoted 1 line · Pranith Kumar
Update the comment which is not true since MTTCG.
What happened to the cover letter? We seem to have a mix of patches but no summary of the overall outcome.
These are a bunch of unrelated patches, so there is no theme. I will include a cover letter saying so from now on.
Thanks,
Signature · 1 line
Pranith