From 4eefab592ac068acfd06fb9422f75a7786fbb855 Mon Sep 17 00:00:00 2001 From: KJ Tsanaktsidis Date: Mon, 11 Dec 2023 15:00:43 +1100 Subject: [PATCH] Refactor local variable names in postponed_job methods Just removes the unneeded `prereg_` prefix from a few local var names. --- vm_trace.c | 36 ++++++++++++++++++------------------ 1 file changed, 18 insertions(+), 18 deletions(-) diff --git a/vm_trace.c b/vm_trace.c index 6969c8d3ceb839..a595b3b2fce699 100644 --- a/vm_trace.c +++ b/vm_trace.c @@ -1682,16 +1682,16 @@ rb_workqueue_register(unsigned flags, rb_postponed_job_func_t func, void *data) return TRUE; } -#define PJOB_PREREG_TABLE_SIZE (sizeof(rb_atomic_t) * CHAR_BIT) +#define PJOB_TABLE_SIZE (sizeof(rb_atomic_t) * CHAR_BIT) /* pre-registered jobs table, for async-safe jobs */ typedef struct rb_postponed_job_queue { struct { rb_postponed_job_func_t func; void *data; - } prereg_table[PJOB_PREREG_TABLE_SIZE]; + } table[PJOB_TABLE_SIZE]; /* Bits in this are set when the corresponding entry in prereg_table has non-zero * triggered_count; i.e. somebody called rb_postponed_job_trigger */ - rb_atomic_t prereg_triggered_bitset; + rb_atomic_t triggered_bitset; } rb_postponed_job_queues_t; void @@ -1700,8 +1700,8 @@ rb_vm_postponed_job_queue_init(rb_vm_t *vm) /* use mimmalloc; postponed job registration is a dependency of objspace, so this gets * called _VERY_ early inside Init_BareVM */ rb_postponed_job_queues_t *pjq = ruby_mimmalloc(sizeof(rb_postponed_job_queues_t)); - pjq->prereg_triggered_bitset = 0; - memset(pjq->prereg_table, 0, sizeof(pjq->prereg_table)); + pjq->triggered_bitset = 0; + memset(pjq->table, 0, sizeof(pjq->table)); vm->postponed_job_queue = pjq; } @@ -1720,7 +1720,7 @@ rb_vm_postponed_job_atfork(void) rb_postponed_job_queues_t *pjq = vm->postponed_job_queue; /* make sure we set the interrupt flag on _this_ thread if we carried any pjobs over * from the other side of the fork */ - if (pjq->prereg_triggered_bitset) { + if (pjq->triggered_bitset) { RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(get_valid_ec(vm)); } @@ -1757,15 +1757,15 @@ rb_postponed_job_preregister(unsigned int flags, rb_postponed_job_func_t func, v * func, however, the data may get mixed up between them. */ rb_postponed_job_queues_t *pjq = GET_VM()->postponed_job_queue; - for (unsigned int i = 0; i < PJOB_PREREG_TABLE_SIZE; i++) { + for (unsigned int i = 0; i < PJOB_TABLE_SIZE; i++) { /* Try and set this slot to equal `func` */ - rb_postponed_job_func_t existing_func = (rb_postponed_job_func_t)RUBY_ATOMIC_PTR_CAS(pjq->prereg_table[i], NULL, (void *)func); + rb_postponed_job_func_t existing_func = (rb_postponed_job_func_t)RUBY_ATOMIC_PTR_CAS(pjq->table[i], NULL, (void *)func); if (existing_func == NULL || existing_func == func) { /* Either this slot was NULL, and we set it to func, or, this slot was already equal to func. * In either case, clobber the data with our data. Note that concurrent calls to * rb_postponed_job_register with the same func & different data will result in either of the * datas being written */ - RUBY_ATOMIC_PTR_EXCHANGE(pjq->prereg_table[i].data, data); + RUBY_ATOMIC_PTR_EXCHANGE(pjq->table[i].data, data); return (rb_postponed_job_handle_t)i; } else { /* Try the next slot if this one already has a func in it */ @@ -1783,7 +1783,7 @@ rb_postponed_job_trigger(rb_postponed_job_handle_t h) rb_vm_t *vm = GET_VM(); rb_postponed_job_queues_t *pjq = vm->postponed_job_queue; - RUBY_ATOMIC_OR(pjq->prereg_triggered_bitset, (((rb_atomic_t)1UL) << h)); + RUBY_ATOMIC_OR(pjq->triggered_bitset, (((rb_atomic_t)1UL) << h)); RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(get_valid_ec(vm)); } @@ -1830,7 +1830,7 @@ rb_postponed_job_flush(rb_vm_t *vm) ccan_list_append_list(&tmp, &vm->workqueue); rb_nativethread_lock_unlock(&vm->workqueue_lock); - rb_atomic_t prereg_triggered_bits = RUBY_ATOMIC_EXCHANGE(pjq->prereg_triggered_bitset, 0); + rb_atomic_t triggered_bits = RUBY_ATOMIC_EXCHANGE(pjq->triggered_bitset, 0); ec->errinfo = Qnil; /* mask POSTPONED_JOB dispatch */ @@ -1839,11 +1839,11 @@ rb_postponed_job_flush(rb_vm_t *vm) EC_PUSH_TAG(ec); if (EC_EXEC_TAG() == TAG_NONE) { /* execute postponed jobs */ - while (prereg_triggered_bits) { - unsigned int i = bit_length(prereg_triggered_bits) - 1; - prereg_triggered_bits ^= ((1UL) << i); /* toggle ith bit off */ - rb_postponed_job_func_t func = pjq->prereg_table[i].func; - void *data = pjq->prereg_table[i].data; + while (triggered_bits) { + unsigned int i = bit_length(triggered_bits) - 1; + triggered_bits ^= ((1UL) << i); /* toggle ith bit off */ + rb_postponed_job_func_t func = pjq->table[i].func; + void *data = pjq->table[i].data; (func)(data); } @@ -1874,8 +1874,8 @@ rb_postponed_job_flush(rb_vm_t *vm) } /* likewise with any remaining-to-be-executed bits of the preregistered postponed * job table */ - if (prereg_triggered_bits) { - RUBY_ATOMIC_OR(pjq->prereg_triggered_bitset, prereg_triggered_bits); + if (triggered_bits) { + RUBY_ATOMIC_OR(pjq->triggered_bitset, triggered_bits); RUBY_VM_SET_POSTPONED_JOB_INTERRUPT(GET_EC()); } }