cpumask_weight
while ((cpumask_weight(&cpus_in_crash) < ncpus) && timeout--) {
loongson_sysconf.cores_per_node = cpumask_weight(&phys_cpus_on_node[0]);
int weight = cpumask_weight(mask);
if (cpumask_weight(mask) > 1) {
if (cpumask_weight(dest) != 1)
while ((cpumask_weight(&cpus_in_crash) < ncpus) && (--msecs > 0)) {
online = cpumask_weight(coupled_mask);
cpumask_weight(topology_core_cpumask(cpu)));
if (cpumask_weight(mask) > cpumask_weight(sibling_mask(cpu)))
if (cpumask_weight(&wd_cpus_enabled) == 1) {
fuzz %= cpumask_weight(mask);
if (cpumask_weight(&xmon_batch_cpus) <= 1) {
if (cpumask_weight(&cpus_in_xmon) >= ncpus)
if (atomic_read(&p.cpus_ack) != cpumask_weight(mask)) {
cpus = cpumask_weight(mask);
seq_printf(m, "siblings : %d\n", cpumask_weight(topology_core_cpumask(n)));
ncpus = cpumask_weight(mask);
ncpus = cpumask_weight(mask);
weight = cpumask_weight(mask);
TP_fast_assign(__entry->ncpus = cpumask_weight(cpus);
TP_fast_assign(__entry->ncpus = cpumask_weight(cpus);
unsigned int nr_offl = cpumask_weight(&cpu_offline_mask);
nr_offl = cpumask_weight(&cpu_offline_mask);
cpumask_weight(topology_core_cpumask(cpu)));
int threads = cpumask_weight(topology_sibling_cpumask(cpu));
if (cpumask_weight(topology_sibling_cpumask(cpu)) == 1)
if (cpumask_weight(topology_sibling_cpumask(sibling)) == 1)
threads = cpumask_weight(topology_sibling_cpumask(cpu));
return (cpumask_weight(topology_core_cpumask(cpu)) > 1) ? 2 : 20;
if (cpumask_weight(mm_cpumask(mm)) <= threshold)
k = n - cpumask_weight(uv_nmi_cpu_mask);
cpumask_weight(uv_nmi_cpu_mask),
cpumask_weight(uv_nmi_cpu_mask),
num = cpumask_weight(mask);
cpumask_weight(cpu_online_mask);
nr_shared = cpumask_weight(&llc->shared_cpu_map);
return cpumask_weight(*map);
return cpumask_weight(*map);
num_cpus = cpumask_weight(timer_cpus);
num_cpus = cpumask_weight(timer_cpus);
for (i = 1; i < cpumask_weight(policy->related_cpus); i++)
for (i = 1; i < cpumask_weight(policy->related_cpus); i++)
const u64 val = (u64)cpumask_weight(qman_affine_cpus()) *
if (cpumask_weight(offlined_cpus) + 1 == nb_available_cpus) {
sub_type_hdr->num_cpu_cores = cpumask_weight(cpumask);
} else if (current->nr_cpus_allowed < cpumask_weight(&set->mask)) {
possible = cpumask_weight(&node_affinity.real_cpu_mask);
ht = cpumask_weight(topology_sibling_cpumask(
cpumask_weight(topology_sibling_cpumask(
if (cpumask_weight(&entry->comp_vect_mask) == 1) {
cpumask_weight(&entry->comp_vect_mask) /
cpumask_weight(&entry->comp_vect_mask) %
possible = cpumask_weight(&entry->def_intr.mask);
n_usr_ctxts = cpumask_weight(&node_affinity.real_cpu_mask);
available_cpus = cpumask_weight(node_cpu_mask);
num_cpus = cpumask_weight(tx_cpumask);
num_cpus = cpumask_weight(tx_cpumask);
if (cpu % cpumask_weight(topology_sibling_cpumask(cpu)))
if (cpumask_weight(&af_desc->mask) > 1)
int all_cpus = cpumask_weight(smt_mask);
phba->cfg_irq_chann = cpumask_weight(aff_mask);
if (cpumask_weight(tmp) > 1)
cpu_cnt = cpumask_weight(aff_mask);
if (cpumask_weight(cpu_online_mask) < 2) {
ord = conn->bitmap_id % cpumask_weight(cpu_online_mask);
ord = conn->bitmap_id % cpumask_weight(conn_allowed_cpumask);
num_cpus = cpumask_weight(cpufreq_cdev->policy->cpus);
unsigned int num_cpus = cpumask_weight(cpufreq_cdev->policy->related_cpus);
cpu_count = cpumask_weight(hfi_instance->cpus);
if (cpumask_weight(hfi_instance->cpus) == 1 && hfi_clients_nr > 0) {
#define num_enabled_cpus() cpumask_weight(cpu_enabled_mask)
#define num_present_cpus() cpumask_weight(cpu_present_mask)
#define num_active_cpus() cpumask_weight(cpu_active_mask)
#define nr_cpus_node(node) cpumask_weight(cpumask_of_node(node))
return cpumask_weight(__sysctl_est_cpulist(ipvs));
TP_fast_assign(__entry->ncpus = cpumask_weight(cpus);
return cpumask_weight(cpumask);
__num_possible_cpus = cpumask_weight(&__cpu_possible_mask);
set_vecs = cpumask_weight(cpu_possible_mask);
nr_irqs = cpumask_weight(dest);
nr_irqs = cpumask_weight(dest);
cpu_index = *cb_cpu % cpumask_weight(pd->cpumask.cbcpu);
int cpu_index = seq_nr % cpumask_weight(pd->cpumask.pcpu);
nr_cpus = cpumask_weight(to_cpumask(pd->cpus));
num_cpus = cpumask_weight(cpus);
if (cpumask_weight(test_cpus) == 1)
rtp->n_ipis += cpumask_weight(cpu_online_mask);
p->nr_cpus_allowed = cpumask_weight(ctx->new_mask);
if (cpumask_weight(smt_mask) == 1)
if (cpumask_weight(smt_mask) == 1) {
if (cpumask_weight(cpu_smt_mask(cpu)) == 2)
if (cpumask_weight(cpu_smt_mask(cpu)) == 2)
__dl_add(dl_b, p->dl.dl_bw, cpumask_weight(rq->rd->span));
__dl_sub(dl_b, p->dl.dl_bw, cpumask_weight(rq->rd->span));
__dl_add(dl_b, p->dl.dl_bw, cpumask_weight(later_rq->rd->span));
ns->weight = cpumask_weight(cpumask_of_node(nid));
weight = cpumask_weight(rd->span);
sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sg_span);
sg->sgc->capacity = SCHED_CAPACITY_SCALE * cpumask_weight(sched_group_span(sg));
sg->group_weight = cpumask_weight(sched_group_span(sg));
if (cpumask_weight(sched_domain_span(sd)) == 1)
sd_weight = cpumask_weight(sd_span);
if (cpumask_weight(cpumask_of_node(node)) != 1)
sd->span_weight = cpumask_weight(sched_domain_span(sd));
size = cpumask_weight(sched_domain_span(sd));
hw_weight = cpumask_weight(&ci->shared_cpu_map);
cpu_stop_init_done(&done, cpumask_weight(cpumask));
.num_threads = cpumask_weight(smt_mask),
cpumask_weight(dev->cpumask) == 1 &&
single = cpumask_weight(pred->mask) == 1;
size_t min_desc_size = trace_buffer_desc_size(buffer_size, cpumask_weight(cpumask));
ncpus = cpumask_weight(nmsk);
if (!cpumask_weight(cluster_mask))
nc = cpumask_weight(nmsk);
ncpus = cpumask_weight(nmsk);
"%s contains %sCPUs %*pbl", #m, (cpumask_weight(m) ? "" : "no "), \
int mask_weight = cpumask_weight(m); \
weight = cpumask_weight(&mask_tmp); \
int mask_weight = cpumask_weight(m); \
KUNIT_EXPECT_EQ_MSG(test, 0, cpumask_weight(&mask_empty), MASK_MSG(&mask_empty));
KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(cpu_possible_mask),
KUNIT_EXPECT_EQ_MSG(test, nr_cpu_ids, cpumask_weight(&mask_all), MASK_MSG(&mask_all));
const int n_stress_kthread = cpumask_weight(cpu_online_mask);
return max(cpumask_weight(node_cpumask), 1U);
nr_split_cpus = cpumask_weight(cpumask_of_node(zone_to_nid(zone))) + cpu_online;
nr_purge_nodes = cpumask_weight(&purge_nodes);
RPS_MAP_SIZE(cpumask_weight(mask)), L1_CACHE_BYTES),
return cpumask_weight(srcp);