arch/x86/kernel/smpboot.c

1286

int threads = cpumask_weight(topology_sibling_cpumask(cpu));

arch/x86/kernel/smpboot.c

1288

if (threads > max_threads)

arch/x86/kernel/smpboot.c

1289

max_threads = threads;

arch/x86/kernel/smpboot.c

680

int i, threads;

arch/x86/kernel/smpboot.c

713

threads = cpumask_weight(topology_sibling_cpumask(cpu));

arch/x86/kernel/smpboot.c

714

if (threads > __max_smt_threads)

arch/x86/kernel/smpboot.c

715

__max_smt_threads = threads;

arch/x86/kernel/smpboot.c

718

cpu_data(i).smt_active = threads > 1;

arch/x86/kernel/smpboot.c

733

if (threads == 1) {

drivers/acpi/acpica/aclocal.h

1200

acpi_thread_id *threads;

drivers/acpi/acpica/dbexec.c

533

if (info->threads && (info->num_created < info->num_threads)) {

drivers/acpi/acpica/dbexec.c

534

info->threads[info->num_created++] = acpi_os_get_thread_id();

drivers/acpi/acpica/dbexec.c

787

acpi_gbl_db_method_info.threads = acpi_os_allocate(size);

drivers/acpi/acpica/dbexec.c

788

if (acpi_gbl_db_method_info.threads == NULL) {

drivers/acpi/acpica/dbexec.c

795

memset(acpi_gbl_db_method_info.threads, 0, size);

drivers/acpi/acpica/dbexec.c

873

acpi_os_free(acpi_gbl_db_method_info.threads);

drivers/acpi/acpica/dbexec.c

874

acpi_gbl_db_method_info.threads = NULL;

drivers/android/binder.c

1558

if (proc->is_dead && RB_EMPTY_ROOT(&proc->threads) &&

drivers/android/binder.c

5253

struct rb_node **p = &proc->threads.rb_node;

drivers/android/binder.c

5276

rb_insert_color(&thread->rb_node, &proc->threads);

drivers/android/binder.c

5360

rb_erase(&thread->rb_node, &proc->threads);

drivers/android/binder.c

5617

for (n = rb_first(&proc->threads); n; n = rb_next(n)) {

drivers/android/binder.c

587

for (n = rb_first(&proc->threads); n != NULL; n = rb_next(n)) {

drivers/android/binder.c

6163

for (n = rb_first(&proc->threads); n != NULL; n = rb_next(n)) {

drivers/android/binder.c

6264

int threads, nodes, incoming_refs, outgoing_refs, active_transactions;

drivers/android/binder.c

6290

threads = 0;

drivers/android/binder.c

6292

while ((n = rb_first(&proc->threads))) {

drivers/android/binder.c

6297

threads++;

drivers/android/binder.c

6342

__func__, proc->pid, threads, nodes, incoming_refs,

drivers/android/binder.c

6634

for (n = rb_first(&proc->threads); n; n = rb_next(n))

drivers/android/binder.c

6798

for (n = rb_first(&proc->threads); n; n = rb_next(n))

drivers/android/binder_internal.h

419

struct rb_root threads;

drivers/dma-buf/st-dma-fence-chain.c

444

struct task_struct **threads;

drivers/dma-buf/st-dma-fence-chain.c

453

threads = kmalloc_objs(*threads, ncpus);

drivers/dma-buf/st-dma-fence-chain.c

454

if (!threads) {

drivers/dma-buf/st-dma-fence-chain.c

461

threads[i] = kthread_run(__find_race, &data, "dmabuf/%d", i);

drivers/dma-buf/st-dma-fence-chain.c

462

if (IS_ERR(threads[i])) {

drivers/dma-buf/st-dma-fence-chain.c

467

get_task_struct(threads[i]);

drivers/dma-buf/st-dma-fence-chain.c

477

ret = kthread_stop_put(threads[i]);

drivers/dma-buf/st-dma-fence-chain.c

481

kfree(threads);

drivers/dma/dmatest.c

1013

list_add_tail(&thread->node, &dtc->threads);

drivers/dma/dmatest.c

1035

INIT_LIST_HEAD(&dtc->threads);

drivers/dma/dmatest.c

1141

list_for_each_entry(thread, &dtc->threads, node) {

drivers/dma/dmatest.c

1329

list_for_each_entry(thread, &dtc->threads, node) {

drivers/dma/dmatest.c

246

struct list_head threads;

drivers/dma/dmatest.c

259

list_for_each_entry(thread, &dtc->threads, node) {

drivers/dma/dmatest.c

275

list_for_each_entry(thread, &dtc->threads, node) {

drivers/dma/dmatest.c

954

list_for_each_entry_safe(thread, _thread, &dtc->threads, node) {

drivers/firmware/psci/psci_checker.c

369

struct task_struct **threads;

drivers/firmware/psci/psci_checker.c

372

threads = kmalloc_objs(*threads, nb_available_cpus);

drivers/firmware/psci/psci_checker.c

373

if (!threads)

drivers/firmware/psci/psci_checker.c

403

threads[nb_threads++] = thread;

drivers/firmware/psci/psci_checker.c

419

wake_up_process(threads[i]);

drivers/firmware/psci/psci_checker.c

427

err += kthread_park(threads[i]);

drivers/firmware/psci/psci_checker.c

428

err += kthread_stop(threads[i]);

drivers/firmware/psci/psci_checker.c

432

kfree(threads);

drivers/gpu/drm/i915/gt/gen7_renderclear.c

266

u32 threads = bv->max_threads - 1;

drivers/gpu/drm/i915/gt/gen7_renderclear.c

275

*cs++ = threads << 16 | 1 << 8 | mode << 2;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1012

memset(threads, 0, sizeof(*threads) * I915_NUM_ENGINES);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1016

threads[tmp].resets =

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1025

threads[tmp].engine = other;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1026

threads[tmp].flags = flags;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1037

threads[tmp].worker = worker;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1039

kthread_init_work(&threads[tmp].work, active_engine);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1040

kthread_queue_work(threads[tmp].worker,

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1041

&threads[tmp].work);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1178

reported -= threads[engine->id].resets;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1191

if (!threads[tmp].worker)

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1194

WRITE_ONCE(threads[tmp].stop, true);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1195

kthread_flush_work(&threads[tmp].work);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1196

ret = READ_ONCE(threads[tmp].result);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1204

kthread_destroy_worker(threads[tmp].worker);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1209

threads[tmp].resets !=

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1214

threads[tmp].resets);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

1237

kfree(threads);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

968

struct active_engine *threads;

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

989

threads = kmalloc_objs(*threads, I915_NUM_ENGINES);

drivers/gpu/drm/i915/gt/selftest_hangcheck.c

990

if (!threads)

drivers/gpu/drm/i915/gt/selftest_slpc.c

499

struct slpc_thread *threads;

drivers/gpu/drm/i915/gt/selftest_slpc.c

502

threads = kzalloc_objs(*threads, I915_MAX_GT);

drivers/gpu/drm/i915/gt/selftest_slpc.c

503

if (!threads)

drivers/gpu/drm/i915/gt/selftest_slpc.c

507

threads[i].worker = kthread_run_worker(0, "igt/slpc_parallel:%d", gt->info.id);

drivers/gpu/drm/i915/gt/selftest_slpc.c

509

if (IS_ERR(threads[i].worker)) {

drivers/gpu/drm/i915/gt/selftest_slpc.c

510

ret = PTR_ERR(threads[i].worker);

drivers/gpu/drm/i915/gt/selftest_slpc.c

514

threads[i].gt = gt;

drivers/gpu/drm/i915/gt/selftest_slpc.c

515

kthread_init_work(&threads[i].work, slpc_spinner_thread);

drivers/gpu/drm/i915/gt/selftest_slpc.c

516

kthread_queue_work(threads[i].worker, &threads[i].work);

drivers/gpu/drm/i915/gt/selftest_slpc.c

522

if (IS_ERR_OR_NULL(threads[i].worker))

drivers/gpu/drm/i915/gt/selftest_slpc.c

525

kthread_flush_work(&threads[i].work);

drivers/gpu/drm/i915/gt/selftest_slpc.c

526

status = READ_ONCE(threads[i].result);

drivers/gpu/drm/i915/gt/selftest_slpc.c

531

kthread_destroy_worker(threads[i].worker);

drivers/gpu/drm/i915/gt/selftest_slpc.c

534

kfree(threads);

drivers/gpu/drm/i915/selftests/i915_request.c

1619

struct parallel_thread *threads;

drivers/gpu/drm/i915/selftests/i915_request.c

1629

threads = kzalloc_objs(*threads, nengines);

drivers/gpu/drm/i915/selftests/i915_request.c

1630

if (!threads)

drivers/gpu/drm/i915/selftests/i915_request.c

1656

threads[idx].worker = worker;

drivers/gpu/drm/i915/selftests/i915_request.c

1657

threads[idx].result = 0;

drivers/gpu/drm/i915/selftests/i915_request.c

1658

threads[idx].engine = engine;

drivers/gpu/drm/i915/selftests/i915_request.c

1660

kthread_init_work(&threads[idx].work, *fn);

drivers/gpu/drm/i915/selftests/i915_request.c

1661

kthread_queue_work(worker, &threads[idx].work);

drivers/gpu/drm/i915/selftests/i915_request.c

1669

if (!threads[idx].worker)

drivers/gpu/drm/i915/selftests/i915_request.c

1672

kthread_flush_work(&threads[idx].work);

drivers/gpu/drm/i915/selftests/i915_request.c

1673

status = READ_ONCE(threads[idx].result);

drivers/gpu/drm/i915/selftests/i915_request.c

1677

kthread_destroy_worker(threads[idx++].worker);

drivers/gpu/drm/i915/selftests/i915_request.c

1684

kfree(threads);

drivers/gpu/drm/i915/selftests/i915_request.c

1733

struct smoke_thread *threads;

drivers/gpu/drm/i915/selftests/i915_request.c

1763

threads = kzalloc_objs(*threads, ncpus * nengines);

drivers/gpu/drm/i915/selftests/i915_request.c

1764

if (!threads) {

drivers/gpu/drm/i915/selftests/i915_request.c

1814

threads[i].worker = worker;

drivers/gpu/drm/i915/selftests/i915_request.c

1815

threads[i].t = &smoke[idx];

drivers/gpu/drm/i915/selftests/i915_request.c

1817

kthread_init_work(&threads[i].work,

drivers/gpu/drm/i915/selftests/i915_request.c

1819

kthread_queue_work(worker, &threads[i].work);

drivers/gpu/drm/i915/selftests/i915_request.c

1836

if (!threads[i].worker)

drivers/gpu/drm/i915/selftests/i915_request.c

1839

WRITE_ONCE(threads[i].stop, true);

drivers/gpu/drm/i915/selftests/i915_request.c

1840

kthread_flush_work(&threads[i].work);

drivers/gpu/drm/i915/selftests/i915_request.c

1841

err = READ_ONCE(threads[i].result);

drivers/gpu/drm/i915/selftests/i915_request.c

1845

kthread_destroy_worker(threads[i].worker);

drivers/gpu/drm/i915/selftests/i915_request.c

1859

kfree(threads);

drivers/gpu/drm/i915/selftests/i915_request.c

465

struct smoke_thread *threads;

drivers/gpu/drm/i915/selftests/i915_request.c

475

threads = kzalloc_objs(*threads, ncpus);

drivers/gpu/drm/i915/selftests/i915_request.c

476

if (!threads)

drivers/gpu/drm/i915/selftests/i915_request.c

503

threads[n].worker = worker;

drivers/gpu/drm/i915/selftests/i915_request.c

504

threads[n].t = &t;

drivers/gpu/drm/i915/selftests/i915_request.c

505

threads[n].stop = false;

drivers/gpu/drm/i915/selftests/i915_request.c

506

threads[n].result = 0;

drivers/gpu/drm/i915/selftests/i915_request.c

508

kthread_init_work(&threads[n].work,

drivers/gpu/drm/i915/selftests/i915_request.c

510

kthread_queue_work(worker, &threads[n].work);

drivers/gpu/drm/i915/selftests/i915_request.c

518

WRITE_ONCE(threads[n].stop, true);

drivers/gpu/drm/i915/selftests/i915_request.c

519

kthread_flush_work(&threads[n].work);

drivers/gpu/drm/i915/selftests/i915_request.c

520

err = READ_ONCE(threads[n].result);

drivers/gpu/drm/i915/selftests/i915_request.c

524

kthread_destroy_worker(threads[n].worker);

drivers/gpu/drm/i915/selftests/i915_request.c

539

kfree(threads);

drivers/md/dm-vdo/completion.c

126

vdo_enqueue_work_queue(vdo->threads[thread_id].queue, completion);

drivers/md/dm-vdo/dump.c

69

if (((dump_options_requested & FLAG_SHOW_QUEUES) != 0) && (vdo->threads != NULL)) {

drivers/md/dm-vdo/dump.c

73

vdo_dump_work_queue(vdo->threads[id].queue);

drivers/md/dm-vdo/io-submitter.c

435

bio_queue_data->queue = vdo->threads[vdo->thread_config.bio_threads[i]].queue;

drivers/md/dm-vdo/vdo.c

1059

vdo->threads[id].is_read_only = is_read_only;

drivers/md/dm-vdo/vdo.c

1146

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

1250

thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

1290

return vdo->threads[vdo_get_callback_thread_id()].is_read_only;

drivers/md/dm-vdo/vdo.c

1614

BUG_ON(thread != &thread->vdo->threads[thread_id]);

drivers/md/dm-vdo/vdo.c

414

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.c

558

struct vdo_thread, __func__, &vdo->threads);

drivers/md/dm-vdo/vdo.c

627

if (vdo->threads == NULL)

drivers/md/dm-vdo/vdo.c

634

vdo_finish_work_queue(vdo->threads[i].queue);

drivers/md/dm-vdo/vdo.c

704

if (vdo->threads != NULL) {

drivers/md/dm-vdo/vdo.c

706

free_listeners(&vdo->threads[i]);

drivers/md/dm-vdo/vdo.c

707

vdo_free_work_queue(vdo_forget(vdo->threads[i].queue));

drivers/md/dm-vdo/vdo.c

709

vdo_free(vdo_forget(vdo->threads));

drivers/md/dm-vdo/vdo.c

991

struct vdo_thread *thread = &vdo->threads[thread_id];

drivers/md/dm-vdo/vdo.h

168

struct vdo_thread *threads;

drivers/ntb/test/ntb_perf.c

1072

wake_up(&perf->threads[tidx].dma_wait);

drivers/ntb/test/ntb_perf.c

1073

cancel_work_sync(&perf->threads[tidx].work);

drivers/ntb/test/ntb_perf.c

1094

pthr = &perf->threads[tidx];

drivers/ntb/test/ntb_perf.c

1128

pthr = &perf->threads[tidx];

drivers/ntb/test/ntb_perf.c

1160

pthr = &perf->threads[tidx];

drivers/ntb/test/ntb_perf.c

201

struct perf_thread threads[MAX_THREADS_CNT];

drivers/s390/net/qeth_core.h

1043

void qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads,

drivers/s390/net/qeth_core_main.c

159

void qeth_set_allowed_threads(struct qeth_card *card, unsigned long threads,

drivers/s390/net/qeth_core_main.c

165

card->thread_allowed_mask = threads;

drivers/s390/net/qeth_core_main.c

167

card->thread_start_mask &= threads;

drivers/s390/net/qeth_core_main.c

173

int qeth_threads_running(struct qeth_card *card, unsigned long threads)

drivers/s390/net/qeth_core_main.c

179

rc = (card->thread_running_mask & threads);

fs/binfmt_elf.c

1957

struct elf_thread_core_info *threads = info->thread;

fs/binfmt_elf.c

1958

while (threads) {

fs/binfmt_elf.c

1960

struct elf_thread_core_info *t = threads;

fs/binfmt_elf.c

1961

threads = t->next;

include/uapi/linux/map_benchmark.h

25

__u32 threads; /* how many threads will do map/unmap in parallel */

kernel/cpu.c

2890

static bool cpu_smt_num_threads_valid(unsigned int threads)

kernel/cpu.c

2893

return threads >= 1 && threads <= cpu_smt_max_threads;

kernel/cpu.c

2894

return threads == 1 || threads == cpu_smt_max_threads;

kernel/dma/map_benchmark.c

118

int threads = map->bparam.threads;

kernel/dma/map_benchmark.c

124

tsk = kmalloc_objs(*tsk, threads);

kernel/dma/map_benchmark.c

130

for (i = 0; i < threads; i++) {

kernel/dma/map_benchmark.c

152

for (i = 0; i < threads; i++) {

kernel/dma/map_benchmark.c

160

for (i = 0; i < threads; i++) {

kernel/dma/map_benchmark.c

212

if (map->bparam.threads == 0 ||

kernel/dma/map_benchmark.c

213

map->bparam.threads > DMA_MAP_MAX_THREADS) {

kernel/fork.c

3276

int threads = max_threads;

kernel/fork.c

3281

t.data = &threads;

kernel/fork.c

3289

max_threads = threads;

kernel/fork.c

810

u64 threads;

kernel/fork.c

818

threads = MAX_THREADS;

kernel/fork.c

820

threads = div64_u64((u64) nr_pages * (u64) PAGE_SIZE,

kernel/fork.c

823

if (threads > max_threads_suggested)

kernel/fork.c

824

threads = max_threads_suggested;

kernel/fork.c

826

max_threads = clamp_t(u64, threads, MIN_THREADS, MAX_THREADS);

kernel/futex/core.c

1891

unsigned int threads, buckets, current_buckets = 0;

kernel/futex/core.c

1898

threads = min_t(unsigned int,

kernel/futex/core.c

1915

buckets = roundup_pow_of_two(4 * threads);

kernel/kcsan/kcsan_test.c

1529

if (WARN_ON(threads))

kernel/kcsan/kcsan_test.c

1541

threads = kzalloc_objs(struct task_struct *, nthreads + 1);

kernel/kcsan/kcsan_test.c

1542

if (WARN_ON(!threads))

kernel/kcsan/kcsan_test.c

1545

threads[nthreads] = NULL;

kernel/kcsan/kcsan_test.c

1547

if (torture_create_kthread(access_thread, NULL, threads[i]))

kernel/kcsan/kcsan_test.c

1556

kfree(threads);

kernel/kcsan/kcsan_test.c

1557

threads = NULL;

kernel/kcsan/kcsan_test.c

1577

if (threads) {

kernel/kcsan/kcsan_test.c

1578

for (stop_thread = threads; *stop_thread; stop_thread++)

kernel/kcsan/kcsan_test.c

1581

kfree(threads);

kernel/kcsan/kcsan_test.c

1582

threads = NULL;

kernel/kcsan/kcsan_test.c

49

static struct task_struct **threads; /* Lists of threads. */

lib/lwq.c

105

struct task_struct *threads[8];

lib/lwq.c

110

for (i = 0; i < ARRAY_SIZE(threads); i++)

lib/lwq.c

111

threads[i] = kthread_run(lwq_exercise, &q, "lwq-test-%d", i);

lib/lwq.c

122

for (i = 0; i < ARRAY_SIZE(threads); i++)

lib/lwq.c

123

if (!IS_ERR_OR_NULL(threads[i]))

lib/lwq.c

124

kthread_stop(threads[i]);

net/sunrpc/svc.c

921

int threads = base;

net/sunrpc/svc.c

924

++threads;

net/sunrpc/svc.c

928

err = svc_set_pool_threads(serv, pool, min_threads, threads);

tools/dma/dma_map_benchmark.c

107

map.threads = threads;

tools/dma/dma_map_benchmark.c

120

threads, seconds, node, directions[dir], granule);

tools/dma/dma_map_benchmark.c

28

int threads = 1, seconds = 20, node = -1;

tools/dma/dma_map_benchmark.c

39

threads = atoi(optarg);

tools/dma/dma_map_benchmark.c

64

if (threads <= 0 || threads > DMA_MAP_MAX_THREADS) {

tools/lib/perf/evlist.c

146

perf_thread_map__put(evsel->threads);

tools/lib/perf/evlist.c

147

evsel->threads = perf_thread_map__new_dummy();

tools/lib/perf/evlist.c

149

perf_thread_map__put(evsel->threads);

tools/lib/perf/evlist.c

150

evsel->threads = perf_thread_map__get(evlist->threads);

tools/lib/perf/evlist.c

240

perf_thread_map__put(evlist->threads);

tools/lib/perf/evlist.c

243

evlist->threads = NULL;

tools/lib/perf/evlist.c

261

struct perf_thread_map *threads)

tools/lib/perf/evlist.c

275

if (threads != evlist->threads) {

tools/lib/perf/evlist.c

276

perf_thread_map__put(evlist->threads);

tools/lib/perf/evlist.c

277

evlist->threads = perf_thread_map__get(threads);

tools/lib/perf/evlist.c

289

err = perf_evsel__open(evsel, evsel->cpus, evsel->threads);

tools/lib/perf/evlist.c

413

int nr_threads = perf_thread_map__nr(evlist->threads);

tools/lib/perf/evlist.c

497

sid->tid = perf_thread_map__pid(evsel->threads, thread);

tools/lib/perf/evlist.c

637

int nr_threads = perf_thread_map__nr(evlist->threads);

tools/lib/perf/evlist.c

679

int nr_threads = perf_thread_map__nr(evlist->threads);

tools/lib/perf/evlist.c

715

nr_mmaps += perf_thread_map__nr(evlist->threads);

tools/lib/perf/evsel.c

127

struct perf_thread_map *threads)

tools/lib/perf/evsel.c

144

if (threads == NULL) {

tools/lib/perf/evsel.c

153

threads = empty_thread_map;

tools/lib/perf/evsel.c

157

perf_evsel__alloc_fd(evsel, perf_cpu_map__nr(cpus), threads->nr) < 0)

tools/lib/perf/evsel.c

161

for (thread = 0; thread < threads->nr; thread++) {

tools/lib/perf/evsel.c

175

threads->map[thread].pid,

tools/lib/perf/evsel.c

50

perf_thread_map__put(evsel->threads);

tools/lib/perf/evsel.c

518

return evsel->threads;

tools/lib/perf/include/internal/evlist.h

29

struct perf_thread_map *threads;

tools/lib/perf/include/internal/evsel.h

103

struct perf_thread_map *threads;

tools/lib/perf/include/perf/evlist.h

33

struct perf_thread_map *threads);

tools/lib/perf/include/perf/evsel.h

31

struct perf_thread_map *threads);

tools/lib/perf/include/perf/threadmap.h

15

LIBPERF_API int perf_thread_map__nr(struct perf_thread_map *threads);

tools/lib/perf/tests/test-evlist.c

108

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evlist.c

109

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evlist.c

111

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evlist.c

130

perf_evlist__set_maps(evlist, NULL, threads);

tools/lib/perf/tests/test-evlist.c

143

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evlist.c

150

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evlist.c

165

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evlist.c

166

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evlist.c

168

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evlist.c

187

perf_evlist__set_maps(evlist, NULL, threads);

tools/lib/perf/tests/test-evlist.c

209

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evlist.c

219

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evlist.c

261

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evlist.c

262

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evlist.c

267

perf_thread_map__set_pid(threads, 0, pid);

tools/lib/perf/tests/test-evlist.c

278

perf_evlist__set_maps(evlist, cpus, threads);

tools/lib/perf/tests/test-evlist.c

312

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evlist.c

443

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evlist.c

460

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evlist.c

461

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evlist.c

463

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evlist.c

468

err = perf_evsel__open(evsel, NULL, threads);

tools/lib/perf/tests/test-evlist.c

490

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evlist.c

493

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evlist.c

494

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evlist.c

496

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evlist.c

507

perf_evlist__set_maps(evlist, NULL, threads);

tools/lib/perf/tests/test-evlist.c

569

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evlist.c

95

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evsel.c

100

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evsel.c

105

err = perf_evsel__open(evsel, NULL, threads);

tools/lib/perf/tests/test-evsel.c

123

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evsel.c

130

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evsel.c

142

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evsel.c

143

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evsel.c

145

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evsel.c

150

err = perf_evsel__open(evsel, NULL, threads);

tools/lib/perf/tests/test-evsel.c

191

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evsel.c

195

static int test_stat_read_format_single(struct perf_event_attr *attr, struct perf_thread_map *threads)

tools/lib/perf/tests/test-evsel.c

206

err = perf_evsel__open(evsel, NULL, threads);

tools/lib/perf/tests/test-evsel.c

230

static int test_stat_read_format_group(struct perf_event_attr *attr, struct perf_thread_map *threads)

tools/lib/perf/tests/test-evsel.c

249

err = perf_evsel__open(leader, NULL, threads);

tools/lib/perf/tests/test-evsel.c

252

err = perf_evsel__open(member, NULL, threads);

tools/lib/perf/tests/test-evsel.c

293

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evsel.c

317

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evsel.c

318

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evsel.c

320

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evsel.c

327

err = test_stat_read_format_single(&attr, threads);

tools/lib/perf/tests/test-evsel.c

331

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evsel.c

333

threads = perf_thread_map__new_array(2, NULL);

tools/lib/perf/tests/test-evsel.c

334

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evsel.c

336

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evsel.c

337

perf_thread_map__set_pid(threads, 1, 0);

tools/lib/perf/tests/test-evsel.c

344

err = test_stat_read_format_group(&attr, threads);

tools/lib/perf/tests/test-evsel.c

348

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evsel.c

56

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evsel.c

64

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evsel.c

65

__T("failed to create threads", threads);

tools/lib/perf/tests/test-evsel.c

67

perf_thread_map__set_pid(threads, 0, 0);

tools/lib/perf/tests/test-evsel.c

72

err = perf_evsel__open(evsel, NULL, threads);

tools/lib/perf/tests/test-evsel.c

81

perf_thread_map__put(threads);

tools/lib/perf/tests/test-evsel.c

88

struct perf_thread_map *threads;

tools/lib/perf/tests/test-evsel.c

97

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-evsel.c

98

__T("failed to create threads", threads);

tools/lib/perf/tests/test-threadmap.c

16

struct perf_thread_map *threads;

tools/lib/perf/tests/test-threadmap.c

19

threads = perf_thread_map__new_array(nr, array);

tools/lib/perf/tests/test-threadmap.c

20

__T("Failed to allocate new thread map", threads);

tools/lib/perf/tests/test-threadmap.c

22

__T("Unexpected number of threads", perf_thread_map__nr(threads) == nr);

tools/lib/perf/tests/test-threadmap.c

26

perf_thread_map__pid(threads, i) == (array ? array[i] : -1));

tools/lib/perf/tests/test-threadmap.c

30

perf_thread_map__set_pid(threads, i, i * 100);

tools/lib/perf/tests/test-threadmap.c

33

perf_thread_map__pid(threads, 0) == (array ? array[0] : -1));

tools/lib/perf/tests/test-threadmap.c

37

perf_thread_map__pid(threads, i) == i * 100);

tools/lib/perf/tests/test-threadmap.c

40

perf_thread_map__put(threads);

tools/lib/perf/tests/test-threadmap.c

48

struct perf_thread_map *threads;

tools/lib/perf/tests/test-threadmap.c

56

threads = perf_thread_map__new_dummy();

tools/lib/perf/tests/test-threadmap.c

57

if (!threads)

tools/lib/perf/tests/test-threadmap.c

60

perf_thread_map__get(threads);

tools/lib/perf/tests/test-threadmap.c

61

perf_thread_map__put(threads);

tools/lib/perf/tests/test-threadmap.c

62

perf_thread_map__put(threads);

tools/lib/perf/threadmap.c

108

int perf_thread_map__idx(struct perf_thread_map *threads, pid_t pid)

tools/lib/perf/threadmap.c

110

if (!threads)

tools/lib/perf/threadmap.c

113

for (int i = 0; i < threads->nr; ++i) {

tools/lib/perf/threadmap.c

114

if (threads->map[i].pid == pid)

tools/lib/perf/threadmap.c

47

struct perf_thread_map *threads = thread_map__alloc(nr_threads);

tools/lib/perf/threadmap.c

50

if (!threads)

tools/lib/perf/threadmap.c

54

perf_thread_map__set_pid(threads, i, array ? array[i] : -1);

tools/lib/perf/threadmap.c

56

threads->nr = nr_threads;

tools/lib/perf/threadmap.c

57

refcount_set(&threads->refcnt, 1);

tools/lib/perf/threadmap.c

59

return threads;

tools/lib/perf/threadmap.c

67

static void perf_thread_map__delete(struct perf_thread_map *threads)

tools/lib/perf/threadmap.c

69

if (threads) {

tools/lib/perf/threadmap.c

72

WARN_ONCE(refcount_read(&threads->refcnt) != 0,

tools/lib/perf/threadmap.c

74

for (i = 0; i < threads->nr; i++)

tools/lib/perf/threadmap.c

75

free(perf_thread_map__comm(threads, i));

tools/lib/perf/threadmap.c

76

free(threads);

tools/lib/perf/threadmap.c

93

int perf_thread_map__nr(struct perf_thread_map *threads)

tools/lib/perf/threadmap.c

95

return threads ? threads->nr : 1;

tools/perf/bench/breakpoint.c

104

pthread_join(threads[i], NULL);

tools/perf/bench/breakpoint.c

106

free(threads);

tools/perf/bench/breakpoint.c

203

pthread_t *threads;

tools/perf/bench/breakpoint.c

220

threads = calloc(nthreads, sizeof(threads[0]));

tools/perf/bench/breakpoint.c

221

if (!threads)

tools/perf/bench/breakpoint.c

225

if (pthread_create(&threads[i], NULL,

tools/perf/bench/breakpoint.c

242

pthread_join(threads[i], NULL);

tools/perf/bench/breakpoint.c

243

free(threads);

tools/perf/bench/breakpoint.c

89

pthread_t *threads;

tools/perf/bench/breakpoint.c

91

threads = calloc(thread_params.nthreads, sizeof(threads[0]));

tools/perf/bench/breakpoint.c

92

if (!threads)

tools/perf/bench/breakpoint.c

98

if (pthread_create(&threads[i], NULL, passive_thread, &done))

tools/perf/bench/evlist-open-close.c

149

printf(" Number of threads:\t%d\n", evlist->core.threads->nr);

tools/perf/bench/evlist-open-close.c

56

cnt += evsel->core.threads->nr * perf_cpu_map__nr(evsel->core.cpus);

tools/perf/bench/numa.c

1033

td = g->threads + task_nr;

tools/perf/bench/numa.c

1102

struct thread_data *td = g->threads + t;

tools/perf/bench/numa.c

1341

this_cpu = g->threads[task_nr].curr_cpu;

tools/perf/bench/numa.c

1421

td = g->threads + task_nr;

tools/perf/bench/numa.c

1436

td = g->threads + task_nr;

tools/perf/bench/numa.c

1481

ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;

tools/perf/bench/numa.c

1484

g->threads = zalloc_shared_data(size);

tools/perf/bench/numa.c

1487

struct thread_data *td = g->threads + t;

tools/perf/bench/numa.c

1505

ssize_t size = sizeof(*g->threads)*g->p.nr_tasks;

tools/perf/bench/numa.c

1510

struct thread_data *td = g->threads + t;

tools/perf/bench/numa.c

1514

free_data(g->threads, size);

tools/perf/bench/numa.c

153

struct thread_data *threads;

tools/perf/bench/numa.c

1715

u64 thread_runtime_ns = g->threads[t].runtime_ns;

tools/perf/bench/numa.c

1777

td = g->threads + p*g->p.nr_threads + t;

tools/perf/bench/numa.c

684

td = g->threads + t;

tools/perf/bench/numa.c

811

td = g->threads + t;

tools/perf/bench/numa.c

965

g->threads[task_nr].curr_cpu = cpu;

tools/perf/bench/numa.c

994

td = g->threads + task_nr;

tools/perf/bench/sched-pipe.c

218

struct thread_data threads[2] = {};

tools/perf/bench/sched-pipe.c

245

td = threads + t;

tools/perf/bench/sched-pipe.c

260

td = threads + t;

tools/perf/bench/sched-pipe.c

267

td = threads + t;

tools/perf/bench/sched-pipe.c

277

worker_thread(threads + 0);

tools/perf/bench/sched-pipe.c

280

worker_thread(threads + 1);

tools/perf/bench/sched-pipe.c

293

if (threads[0].cgroup_failed || threads[1].cgroup_failed)

tools/perf/bench/synthesize.c

117

struct perf_thread_map *threads;

tools/perf/bench/synthesize.c

130

threads = thread_map__new_by_pid(getpid());

tools/perf/bench/synthesize.c

131

if (!threads) {

tools/perf/bench/synthesize.c

141

err = do_run_single_threaded(session, threads, &target, false);

tools/perf/bench/synthesize.c

145

err = do_run_single_threaded(session, threads, &target, true);

tools/perf/bench/synthesize.c

148

if (threads)

tools/perf/bench/synthesize.c

149

perf_thread_map__put(threads);

tools/perf/bench/synthesize.c

63

struct perf_thread_map *threads,

tools/perf/bench/synthesize.c

82

target, threads,

tools/perf/builtin-ftrace.c

379

for (i = 0; i < perf_thread_map__nr(ftrace->evlist->core.threads); i++) {

tools/perf/builtin-ftrace.c

381

perf_thread_map__pid(ftrace->evlist->core.threads, i));

tools/perf/builtin-kvm.c

1935

kvm->evlist->core.threads, true, false, 1);

tools/perf/builtin-record.c

1371

if (evsel__open(pos, pos->core.cpus, pos->core.threads) < 0) {

tools/perf/builtin-record.c

2150

err = perf_event__synthesize_thread_map2(&rec->tool, rec->evlist->core.threads,

tools/perf/builtin-record.c

2191

rec->evlist->core.threads,

tools/perf/builtin-script.c

161

struct perf_thread_map *threads;

tools/perf/builtin-script.c

2301

.system_wide = perf_thread_map__pid(evsel->core.threads, /*idx=*/0) == -1,

tools/perf/builtin-script.c

2343

thread_map_idx = perf_thread_map__idx(evsel->core.threads, sample->tid);

tools/perf/builtin-script.c

2346

if (perf_thread_map__pid(evsel->core.threads, /*idx=*/0) == -1 ||

tools/perf/builtin-script.c

2570

int nthreads = perf_thread_map__nr(counter->core.threads);

tools/perf/builtin-script.c

2589

perf_thread_map__pid(counter->core.threads, thread),

tools/perf/builtin-script.c

3183

perf_thread_map__put(script->threads);

tools/perf/builtin-script.c

3883

if (!script->cpus || !script->threads)

tools/perf/builtin-script.c

3889

perf_evlist__set_maps(&evlist->core, script->cpus, script->threads);

tools/perf/builtin-script.c

3908

if (script->threads) {

tools/perf/builtin-script.c

3913

script->threads = thread_map__new_event(&event->thread_map);

tools/perf/builtin-script.c

3914

if (!script->threads)

tools/perf/builtin-stat.c

151

struct perf_thread_map *threads;

tools/perf/builtin-stat.c

1584

nr = perf_thread_map__nr(evsel_list->core.threads);

tools/perf/builtin-stat.c

1884

int nr = perf_thread_map__nr(evsel_list->core.threads);

tools/perf/builtin-stat.c

2240

if (!st->cpus || !st->threads)

tools/perf/builtin-stat.c

2246

perf_evlist__set_maps(&evsel_list->core, st->cpus, st->threads);

tools/perf/builtin-stat.c

2262

if (st->threads) {

tools/perf/builtin-stat.c

2267

st->threads = thread_map__new_event(&event->thread_map);

tools/perf/builtin-stat.c

2268

if (!st->threads)

tools/perf/builtin-stat.c

2889

thread_map__read_comms(evsel_list->core.threads);

tools/perf/builtin-stat.c

324

int nthreads = perf_thread_map__nr(evsel_list->core.threads);

tools/perf/builtin-stat.c

553

struct perf_thread_map *threads)

tools/perf/builtin-stat.c

561

for (i = 0; i < threads->nr; i++) {

tools/perf/builtin-stat.c

565

threads->map[i].pid);

tools/perf/builtin-stat.c

634

child_exited = !is_target_alive(&target, evsel_list->core.threads) ? 1 : 0;

tools/perf/builtin-stat.c

684

evsel_list->core.threads && evsel_list->core.threads->err_thread != -1) {

tools/perf/builtin-stat.c

689

if (!thread_map__remove(evsel_list->core.threads,

tools/perf/builtin-stat.c

690

evsel_list->core.threads->err_thread)) {

tools/perf/builtin-stat.c

691

evsel_list->core.threads->err_thread = -1;

tools/perf/builtin-stat.c

759

evsel->core.threads);

tools/perf/builtin-top.c

1032

counter->core.threads) < 0) {

tools/perf/builtin-top.c

1298

top->evlist->core.threads, true, false,

tools/perf/builtin-trace.c

2007

evlist->core.threads, trace__tool_process,

tools/perf/builtin-trace.c

4165

} else if (perf_thread_map__pid(trace->evlist->core.threads, 0) == -1) {

tools/perf/builtin-trace.c

4550

trace->multiple_threads = perf_thread_map__pid(evlist->core.threads, 0) == -1 ||

tools/perf/builtin-trace.c

4551

perf_thread_map__nr(evlist->core.threads) > 1 ||

tools/perf/builtin-trace.c

4972

LIST_HEAD(threads);

tools/perf/builtin-trace.c

4974

if (machine__thread_list(trace->host, &threads) == 0) {

tools/perf/builtin-trace.c

4977

list_sort(NULL, &threads, trace_nr_events_cmp);

tools/perf/builtin-trace.c

4979

list_for_each_entry(pos, &threads, list)

tools/perf/builtin-trace.c

4982

thread_list__delete(&threads);

tools/perf/tests/code-reading.c

698

struct perf_thread_map *threads = NULL;

tools/perf/tests/code-reading.c

745

threads = thread_map__new_by_tid(pid);

tools/perf/tests/code-reading.c

746

if (!threads) {

tools/perf/tests/code-reading.c

751

ret = perf_event__synthesize_thread_map(NULL, threads,

tools/perf/tests/code-reading.c

780

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/code-reading.c

848

perf_thread_map__put(threads);

tools/perf/tests/event-times.c

60

struct perf_thread_map *threads;

tools/perf/tests/event-times.c

65

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/event-times.c

66

if (threads == NULL) {

tools/perf/tests/event-times.c

73

err = evsel__open_per_thread(evsel, threads);

tools/perf/tests/event-times.c

79

perf_thread_map__put(threads);

tools/perf/tests/event-times.c

86

struct perf_thread_map *threads;

tools/perf/tests/event-times.c

91

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/event-times.c

92

if (threads == NULL) {

tools/perf/tests/event-times.c

97

err = evsel__open_per_thread(evsel, threads);

tools/perf/tests/event-times.c

99

perf_thread_map__put(threads);

tools/perf/tests/keep-tracking.c

159

perf_thread_map__put(threads);

tools/perf/tests/keep-tracking.c

74

struct perf_thread_map *threads = NULL;

tools/perf/tests/keep-tracking.c

81

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/keep-tracking.c

82

CHECK_NOT_NULL__(threads);

tools/perf/tests/keep-tracking.c

90

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/mmap-basic.c

101

if (evsel__open(evsels[i], cpus, threads) < 0) {

tools/perf/tests/mmap-basic.c

174

perf_thread_map__put(threads);

tools/perf/tests/mmap-basic.c

226

struct perf_thread_map *threads = perf_thread_map__new_dummy();

tools/perf/tests/mmap-basic.c

230

if (!threads) {

tools/perf/tests/mmap-basic.c

234

perf_thread_map__set_pid(threads, 0, 0);

tools/perf/tests/mmap-basic.c

273

err = perf_evsel__open(evsel, NULL, threads);

tools/perf/tests/mmap-basic.c

371

perf_thread_map__put(threads);

tools/perf/tests/mmap-basic.c

39

struct perf_thread_map *threads;

tools/perf/tests/mmap-basic.c

52

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/mmap-basic.c

53

if (threads == NULL) {

tools/perf/tests/mmap-basic.c

80

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/mmap-thread-lookup.c

102

struct thread_data *td0 = &threads[0];

tools/perf/tests/mmap-thread-lookup.c

119

struct thread_data *td0 = &threads[0];

tools/perf/tests/mmap-thread-lookup.c

128

err = pthread_join(threads[i].pt, NULL);

tools/perf/tests/mmap-thread-lookup.c

189

struct thread_data *td = &threads[i];

tools/perf/tests/mmap-thread-lookup.c

33

static struct thread_data threads[THREADS];

tools/perf/tests/mmap-thread-lookup.c

82

struct thread_data *td = &threads[i];

tools/perf/tests/openat-syscall-all-cpus.c

123

perf_thread_map__put(threads);

tools/perf/tests/openat-syscall-all-cpus.c

31

struct perf_thread_map *threads = thread_map__new_by_tid(getpid());

tools/perf/tests/openat-syscall-all-cpus.c

35

if (threads == NULL) {

tools/perf/tests/openat-syscall-all-cpus.c

56

if (evsel__open(evsel, cpus, threads) < 0) {

tools/perf/tests/openat-syscall-tp-fields.c

67

perf_thread_map__set_pid(evlist->core.threads, 0, getpid());

tools/perf/tests/openat-syscall.c

23

struct perf_thread_map *threads = thread_map__new_by_tid(getpid());

tools/perf/tests/openat-syscall.c

27

if (threads == NULL) {

tools/perf/tests/openat-syscall.c

40

if (evsel__open_per_thread(evsel, threads) < 0) {

tools/perf/tests/openat-syscall.c

70

perf_thread_map__put(threads);

tools/perf/tests/perf-time-to-tsc.c

102

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/perf-time-to-tsc.c

206

perf_thread_map__put(threads);

tools/perf/tests/perf-time-to-tsc.c

79

struct perf_thread_map *threads = NULL;

tools/perf/tests/perf-time-to-tsc.c

93

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/perf-time-to-tsc.c

94

CHECK_NOT_NULL__(threads);

tools/perf/tests/sigtrap.c

175

static int run_test_threads(pthread_t *threads, pthread_barrier_t *barrier)

tools/perf/tests/sigtrap.c

181

TEST_ASSERT_EQUAL("pthread_join() failed", pthread_join(threads[i], NULL), 0);

tools/perf/tests/sigtrap.c

186

static int run_stress_test(int fd, pthread_t *threads, pthread_barrier_t *barrier)

tools/perf/tests/sigtrap.c

194

ret = run_test_threads(threads, barrier);

tools/perf/tests/sigtrap.c

224

pthread_t threads[NUM_THREADS];

tools/perf/tests/sigtrap.c

257

if (pthread_create(&threads[i], NULL, test_thread, &barrier)) {

tools/perf/tests/sigtrap.c

263

ret = run_stress_test(fd, threads, &barrier);

tools/perf/tests/sw-clock.c

136

perf_thread_map__put(threads);

tools/perf/tests/sw-clock.c

48

struct perf_thread_map *threads = NULL;

tools/perf/tests/sw-clock.c

67

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/sw-clock.c

68

if (!cpus || !threads) {

tools/perf/tests/sw-clock.c

74

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/switch-tracking.c

346

struct perf_thread_map *threads = NULL;

tools/perf/tests/switch-tracking.c

354

threads = thread_map__new_by_tid(getpid());

tools/perf/tests/switch-tracking.c

355

if (!threads) {

tools/perf/tests/switch-tracking.c

372

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/switch-tracking.c

583

perf_thread_map__put(threads);

tools/perf/tests/task-exit.c

149

perf_thread_map__put(threads);

tools/perf/tests/task-exit.c

54

struct perf_thread_map *threads;

tools/perf/tests/task-exit.c

73

threads = thread_map__new_by_tid(-1);

tools/perf/tests/task-exit.c

74

if (!cpus || !threads) {

tools/perf/tests/task-exit.c

80

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/tests/thread-map.c

101

thread_map__read_comms(threads);

tools/perf/tests/thread-map.c

104

!perf_event__synthesize_thread_map2(NULL, threads, process_event, NULL));

tools/perf/tests/thread-map.c

106

perf_thread_map__put(threads);

tools/perf/tests/thread-map.c

112

struct perf_thread_map *threads;

tools/perf/tests/thread-map.c

118

threads = thread_map__new_str(str, /*tid=*/NULL, /*all_threads=*/false);

tools/perf/tests/thread-map.c

122

threads);

tools/perf/tests/thread-map.c

125

thread_map__fprintf(threads, stderr);

tools/perf/tests/thread-map.c

128

!thread_map__remove(threads, 0));

tools/perf/tests/thread-map.c

130

TEST_ASSERT_VAL("thread_map count != 1", threads->nr == 1);

tools/perf/tests/thread-map.c

133

thread_map__fprintf(threads, stderr);

tools/perf/tests/thread-map.c

136

!thread_map__remove(threads, 0));

tools/perf/tests/thread-map.c

138

TEST_ASSERT_VAL("thread_map count != 0", threads->nr == 0);

tools/perf/tests/thread-map.c

141

thread_map__fprintf(threads, stderr);

tools/perf/tests/thread-map.c

144

thread_map__remove(threads, 0));

tools/perf/tests/thread-map.c

146

perf_thread_map__put(threads);

tools/perf/tests/thread-map.c

69

struct perf_thread_map *threads;

tools/perf/tests/thread-map.c

75

threads = thread_map__new_event(&event->thread_map);

tools/perf/tests/thread-map.c

76

TEST_ASSERT_VAL("failed to alloc map", threads);

tools/perf/tests/thread-map.c

78

TEST_ASSERT_VAL("wrong nr", threads->nr == 1);

tools/perf/tests/thread-map.c

80

perf_thread_map__pid(threads, 0) == getpid());

tools/perf/tests/thread-map.c

82

perf_thread_map__comm(threads, 0) &&

tools/perf/tests/thread-map.c

83

!strcmp(perf_thread_map__comm(threads, 0), NAME));

tools/perf/tests/thread-map.c

85

refcount_read(&threads->refcnt) == 1);

tools/perf/tests/thread-map.c

86

perf_thread_map__put(threads);

tools/perf/tests/thread-map.c

92

struct perf_thread_map *threads;

tools/perf/tests/thread-map.c

98

threads = thread_map__new_by_pid(getpid());

tools/perf/tests/thread-map.c

99

TEST_ASSERT_VAL("failed to alloc map", threads);

tools/perf/util/auxtrace.c

205

mp->tid = perf_thread_map__pid(evlist->core.threads, 0);

tools/perf/util/auxtrace.c

208

mp->tid = perf_thread_map__pid(evlist->core.threads, idx);

tools/perf/util/bpf-filter.c

323

struct perf_thread_map *threads;

tools/perf/util/bpf-filter.c

332

threads = perf_evsel__threads(&pfi->evsel->core);

tools/perf/util/bpf-filter.c

333

if (threads == NULL)

tools/perf/util/bpf-filter.c

337

nr = perf_thread_map__nr(threads);

tools/perf/util/bpf-filter.c

342

.tgid = perf_thread_map__pid(threads, i),

tools/perf/util/bpf-filter.c

357

struct perf_thread_map *threads;

tools/perf/util/bpf-filter.c

394

threads = perf_evsel__threads(&evsel->core);

tools/perf/util/bpf-filter.c

395

if (threads == NULL) {

tools/perf/util/bpf-filter.c

408

nr = perf_thread_map__nr(threads);

tools/perf/util/bpf-filter.c

410

int pid = perf_thread_map__pid(threads, i);

tools/perf/util/bpf_counter.c

443

*filter_entry_cnt = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/bpf_counter.c

446

*filter_entry_cnt = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/bpf_counter.c

463

struct perf_thread_map *threads;

tools/perf/util/bpf_counter.c

501

threads = thread_map__new_by_tid(-1);

tools/perf/util/bpf_counter.c

502

evsel__open(evsel, evsel->core.cpus, threads);

tools/perf/util/bpf_counter.c

503

perf_thread_map__put(threads);

tools/perf/util/bpf_counter.c

625

key = perf_thread_map__pid(evsel->core.threads, i);

tools/perf/util/bpf_ftrace.c

102

pid = perf_thread_map__pid(ftrace->evlist->core.threads, i);

tools/perf/util/bpf_ftrace.c

68

ntasks = perf_thread_map__nr(ftrace->evlist->core.threads);

tools/perf/util/bpf_lock_contention.c

229

ntasks = perf_thread_map__nr(evlist->core.threads);

tools/perf/util/bpf_lock_contention.c

342

pid = perf_thread_map__pid(evlist->core.threads, i);

tools/perf/util/bpf_off_cpu.c

200

ntasks = perf_thread_map__nr(evlist->core.threads);

tools/perf/util/bpf_off_cpu.c

270

pid = perf_thread_map__pid(evlist->core.threads, i);

tools/perf/util/bpf_off_cpu.c

74

perf_thread_map__pid(evlist->core.threads, 0) != -1) {

tools/perf/util/bpf_off_cpu.c

80

pid = perf_thread_map__pid(evlist->core.threads, 0);

tools/perf/util/counts.c

61

int nthreads = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/drm_pmu.c

520

struct perf_thread_map *threads,

tools/perf/util/drm_pmu.c

524

(void)threads;

tools/perf/util/drm_pmu.c

667

int pid = perf_thread_map__pid(evsel->core.threads, thread);

tools/perf/util/drm_pmu.h

35

struct perf_thread_map *threads,

tools/perf/util/event.c

368

struct perf_thread_map *threads = thread_map__new_event(&event->thread_map);

tools/perf/util/event.c

373

if (threads)

tools/perf/util/event.c

374

ret += thread_map__fprintf(threads, fp);

tools/perf/util/event.c

378

perf_thread_map__put(threads);

tools/perf/util/evlist.c

1051

struct perf_thread_map *threads;

tools/perf/util/evlist.c

1071

threads = thread_map__new_str(target->pid, target->tid, all_threads);

tools/perf/util/evlist.c

1073

if (!threads)

tools/perf/util/evlist.c

1086

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/util/evlist.c

1090

perf_thread_map__put(threads);

tools/perf/util/evlist.c

1095

perf_thread_map__put(threads);

tools/perf/util/evlist.c

1410

struct perf_thread_map *threads;

tools/perf/util/evlist.c

1425

threads = perf_thread_map__new_dummy();

tools/perf/util/evlist.c

1426

if (!threads) {

tools/perf/util/evlist.c

1431

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/util/evlist.c

1432

perf_thread_map__put(threads);

tools/perf/util/evlist.c

1446

if (evlist->core.threads == NULL && evlist->core.user_requested_cpus == NULL) {

tools/perf/util/evlist.c

1455

err = evsel__open(evsel, evsel->core.cpus, evsel->core.threads);

tools/perf/util/evlist.c

1557

if (evlist->core.threads == NULL) {

tools/perf/util/evlist.c

1562

perf_thread_map__set_pid(evlist->core.threads, 0, evlist->workload.pid);

tools/perf/util/evlist.c

77

struct perf_thread_map *threads)

tools/perf/util/evlist.c

80

perf_evlist__set_maps(&evlist->core, cpus, threads);

tools/perf/util/evlist.h

110

struct perf_thread_map *threads);

tools/perf/util/evsel.c

2200

struct perf_thread_map *threads,

tools/perf/util/evsel.c

2203

pid_t ignore_pid = perf_thread_map__pid(threads, thread);

tools/perf/util/evsel.c

2217

if (threads->nr == 1)

tools/perf/util/evsel.c

2224

if (update_fds(evsel, nr_cpus, cpu_map_idx, threads->nr, thread))

tools/perf/util/evsel.c

2227

if (thread_map__remove(threads, thread))

tools/perf/util/evsel.c

2279

struct perf_thread_map *threads)

tools/perf/util/evsel.c

2282

int nthreads = perf_thread_map__nr(threads);

tools/perf/util/evsel.c

2298

if (threads == NULL) {

tools/perf/util/evsel.c

2305

threads = empty_thread_map;

tools/perf/util/evsel.c

2367

struct perf_thread_map *threads)

tools/perf/util/evsel.c

2371

err = __evsel__prepare_open(evsel, cpus, threads);

tools/perf/util/evsel.c

2783

struct perf_thread_map *threads,

tools/perf/util/evsel.c

2796

err = __evsel__prepare_open(evsel, cpus, threads);

tools/perf/util/evsel.c

2803

if (threads == NULL)

tools/perf/util/evsel.c

2804

threads = empty_thread_map;

tools/perf/util/evsel.c

2806

nthreads = perf_thread_map__nr(threads);

tools/perf/util/evsel.c

2818

err = evsel__tool_pmu_open(evsel, threads,

tools/perf/util/evsel.c

2824

err = evsel__hwmon_pmu_open(evsel, threads,

tools/perf/util/evsel.c

2830

err = evsel__drm_pmu_open(evsel, threads,

tools/perf/util/evsel.c

2846

pid = perf_thread_map__pid(threads, thread);

tools/perf/util/evsel.c

2917

idx, threads, thread, err)) {

tools/perf/util/evsel.c

2940

threads->err_thread = thread;

tools/perf/util/evsel.c

2959

struct perf_thread_map *threads)

tools/perf/util/evsel.c

2961

return evsel__open_cpu(evsel, cpus, threads, 0, perf_cpu_map__nr(cpus));

tools/perf/util/evsel.c

2974

struct perf_thread_map *threads)

tools/perf/util/evsel.c

2977

return evsel__open_cpu(evsel, cpus, threads, 0, perf_cpu_map__nr(cpus));

tools/perf/util/evsel.c

2979

return evsel__open_cpu(evsel, cpus, threads, cpu_map_idx, cpu_map_idx + 1);

tools/perf/util/evsel.c

2984

struct perf_thread_map *threads = thread_map__new_by_tid(-1);

tools/perf/util/evsel.c

2985

int ret = evsel__open_per_cpu_and_thread(evsel, cpus, cpu_map_idx, threads);

tools/perf/util/evsel.c

2987

perf_thread_map__put(threads);

tools/perf/util/evsel.c

2991

int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads)

tools/perf/util/evsel.c

2994

int ret = evsel__open_per_cpu_and_thread(evsel, cpus, -1, threads);

tools/perf/util/evsel.c

4161

struct perf_thread_map *threads = evsel->core.threads;

tools/perf/util/evsel.c

4163

if (perf_evsel__alloc_id(&evsel->core, perf_cpu_map__nr(cpus), threads->nr))

tools/perf/util/evsel.c

495

evsel->core.threads = perf_thread_map__get(orig->core.threads);

tools/perf/util/evsel.h

358

struct perf_thread_map *threads);

tools/perf/util/evsel.h

360

int evsel__open_per_thread(struct evsel *evsel, struct perf_thread_map *threads);

tools/perf/util/evsel.h

362

struct perf_thread_map *threads);

tools/perf/util/evsel.h

365

struct perf_thread_map *threads);

tools/perf/util/hwmon_pmu.c

759

struct perf_thread_map *threads,

tools/perf/util/hwmon_pmu.c

772

nthreads = perf_thread_map__nr(threads);

tools/perf/util/hwmon_pmu.c

793

threads->err_thread = thread;

tools/perf/util/hwmon_pmu.h

163

struct perf_thread_map *threads,

tools/perf/util/machine.c

1857

return threads__remove(&machine->threads, th);

tools/perf/util/machine.c

204

threads__remove_all_threads(&machine->threads);

tools/perf/util/machine.c

221

threads__exit(&machine->threads);

tools/perf/util/machine.c

3055

return threads__for_each_thread(&machine->threads, fn, priv);

tools/perf/util/machine.c

531

struct thread *th = threads__find(&machine->threads, tid);

tools/perf/util/machine.c

541

th = threads__findnew(&machine->threads, pid, tid, &created);

tools/perf/util/machine.c

553

threads__remove(&machine->threads, th);

tools/perf/util/machine.c

87

threads__init(&machine->threads);

tools/perf/util/machine.c

954

size_t ret = fprintf(fp, "Threads: %zu\n", threads__nr(&machine->threads));

tools/perf/util/machine.h

42

struct threads threads;

tools/perf/util/pfm.c

125

struct perf_thread_map *threads)

tools/perf/util/pfm.c

145

ret = evsel__open(evsel, cpus, threads);

tools/perf/util/pfm.c

155

ret = evsel__open(evsel, cpus, threads);

tools/perf/util/pfm.c

191

struct perf_thread_map *threads = thread_map__new_by_tid(0);

tools/perf/util/pfm.c

232

if (is_libpfm_event_supported(name, cpus, threads)) {

tools/perf/util/pfm.c

264

if (!is_libpfm_event_supported(name, cpus, threads))

tools/perf/util/pfm.c

280

perf_thread_map__put(threads);

tools/perf/util/python.c

1068

struct perf_thread_map *threads = NULL;

tools/perf/util/python.c

1078

threads = ((struct pyrf_thread_map *)pthreads)->threads;

tools/perf/util/python.c

1088

if (evsel__open(evsel, cpus, threads) < 0) {

tools/perf/util/python.c

1113

pthread_map->threads = perf_thread_map__get(pevsel->evsel.core.threads);

tools/perf/util/python.c

1130

nthreads = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/python.c

1164

thread_idx = perf_thread_map__idx(evsel->core.threads, thread);

tools/perf/util/python.c

1280

struct perf_thread_map *threads;

tools/perf/util/python.c

1285

threads = ((struct pyrf_thread_map *)pthreads)->threads;

tools/perf/util/python.c

1287

evlist__init(&pevlist->evlist, cpus, threads);

tools/perf/util/python.c

1445

thread_idx = perf_thread_map__idx(pos2->core.threads, thread);

tools/perf/util/python.c

2009

evlist__init(&pevlist->evlist, evlist->core.all_cpus, evlist->core.threads);

tools/perf/util/python.c

2070

struct perf_thread_map *threads;

tools/perf/util/python.c

2075

threads = pthreads ? ((struct pyrf_thread_map *)pthreads)->threads : NULL;

tools/perf/util/python.c

2079

evlist__init(&evlist, cpus, threads);

tools/perf/util/python.c

2097

struct perf_thread_map *threads;

tools/perf/util/python.c

2103

threads = pthreads ? ((struct pyrf_thread_map *)pthreads)->threads : NULL;

tools/perf/util/python.c

2106

evlist__init(&evlist, cpus, threads);

tools/perf/util/python.c

585

struct perf_thread_map *threads;

tools/perf/util/python.c

598

pthreads->threads = thread_map__new(pid, tid);

tools/perf/util/python.c

599

if (pthreads->threads == NULL)

tools/perf/util/python.c

606

perf_thread_map__put(pthreads->threads);

tools/perf/util/python.c

614

return perf_thread_map__nr(pthreads->threads);

tools/perf/util/python.c

621

if (i >= perf_thread_map__nr(pthreads->threads)) {

tools/perf/util/python.c

626

return Py_BuildValue("i", perf_thread_map__pid(pthreads->threads, i));

tools/perf/util/scripting-engines/trace-event-python.c

1700

struct perf_thread_map *threads = counter->core.threads;

tools/perf/util/scripting-engines/trace-event-python.c

1703

for (int thread = 0; thread < perf_thread_map__nr(threads); thread++) {

tools/perf/util/scripting-engines/trace-event-python.c

1709

perf_thread_map__pid(threads, thread), tstamp,

tools/perf/util/sideband_evlist.c

118

evlist->core.threads) < 0)

tools/perf/util/stat-display.c

297

COMM_LEN, perf_thread_map__comm(evsel->core.threads, id.thread_idx),

tools/perf/util/stat-display.c

298

PID_LEN, perf_thread_map__pid(evsel->core.threads, id.thread_idx));

tools/perf/util/stat-display.c

352

perf_thread_map__comm(evsel->core.threads, id.thread_idx),

tools/perf/util/stat-display.c

353

perf_thread_map__pid(evsel->core.threads, id.thread_idx),

tools/perf/util/stat-display.c

403

perf_thread_map__comm(evsel->core.threads, id.thread_idx),

tools/perf/util/stat-display.c

404

perf_thread_map__pid(evsel->core.threads, id.thread_idx));

tools/perf/util/stat.c

157

int nthreads = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/stat.c

249

int idx, nthreads = perf_thread_map__nr(evsel->core.threads);

tools/perf/util/stat.c

464

int nthreads = perf_thread_map__nr(counter->core.threads);

tools/perf/util/synthetic-events.c

111

threads = NULL;

tools/perf/util/synthetic-events.c

113

threads = strstr(ppids ?: bf, "Threads:");

tools/perf/util/synthetic-events.c

1213

struct perf_thread_map *threads,

tools/perf/util/synthetic-events.c

1221

size += threads->nr * sizeof(event->thread_map.entries[0]);

tools/perf/util/synthetic-events.c

1229

event->thread_map.nr = threads->nr;

tools/perf/util/synthetic-events.c

1231

for (i = 0; i < threads->nr; i++) {

tools/perf/util/synthetic-events.c

1233

char *comm = perf_thread_map__comm(threads, i);

tools/perf/util/synthetic-events.c

1238

entry->pid = perf_thread_map__pid(threads, i);

tools/perf/util/synthetic-events.c

146

if (!vmpeak && threads)

tools/perf/util/synthetic-events.c

1951

struct target *target, struct perf_thread_map *threads,

tools/perf/util/synthetic-events.c

1975

return perf_event__synthesize_thread_map(tool, threads, process, machine,

tools/perf/util/synthetic-events.c

1986

struct perf_thread_map *threads, bool needs_mmap,

tools/perf/util/synthetic-events.c

1989

return __machine__synthesize_threads(machine, NULL, target, threads,

tools/perf/util/synthetic-events.c

2370

err = perf_event__synthesize_thread_map2(tool, evlist->core.threads, process, NULL);

tools/perf/util/synthetic-events.c

80

char *name, *tgids, *ppids, *vmpeak, *threads;

tools/perf/util/synthetic-events.c

869

struct perf_thread_map *threads,

tools/perf/util/synthetic-events.c

897

for (thread = 0; thread < threads->nr; ++thread) {

tools/perf/util/synthetic-events.c

900

perf_thread_map__pid(threads, thread), 0,

tools/perf/util/synthetic-events.c

911

if ((int) comm_event->comm.pid != perf_thread_map__pid(threads, thread)) {

tools/perf/util/synthetic-events.c

915

for (j = 0; j < threads->nr; ++j) {

tools/perf/util/synthetic-events.c

916

if ((int) comm_event->comm.pid == perf_thread_map__pid(threads, j)) {

tools/perf/util/synthetic-events.h

103

struct target *target, struct perf_thread_map *threads,

tools/perf/util/synthetic-events.h

107

struct perf_thread_map *threads, bool needs_mmap, bool data_mmap,

tools/perf/util/synthetic-events.h

89

int perf_event__synthesize_thread_map2(const struct perf_tool *tool, struct perf_thread_map *threads, perf_event__handler_t process, struct machine *machine);

tools/perf/util/synthetic-events.h

90

int perf_event__synthesize_thread_map(const struct perf_tool *tool, struct perf_thread_map *threads, perf_event__handler_t process, struct machine *machine, bool needs_mmap, bool mmap_data);

tools/perf/util/thread_map.c

107

while (threads->nr + items >= max_threads) {

tools/perf/util/thread_map.c

115

tmp = perf_thread_map__realloc(threads, max_threads);

tools/perf/util/thread_map.c

119

threads = tmp;

tools/perf/util/thread_map.c

123

perf_thread_map__set_pid(threads, threads->nr + i,

tools/perf/util/thread_map.c

131

threads->nr += items;

tools/perf/util/thread_map.c

137

return threads;

tools/perf/util/thread_map.c

140

free(threads);

tools/perf/util/thread_map.c

147

zfree(&threads);

tools/perf/util/thread_map.c

161

struct perf_thread_map *threads = NULL, *nt;

tools/perf/util/thread_map.c

188

nt = perf_thread_map__realloc(threads, total_tasks);

tools/perf/util/thread_map.c

192

threads = nt;

tools/perf/util/thread_map.c

195

perf_thread_map__set_pid(threads, j++, atoi(namelist[i]->d_name));

tools/perf/util/thread_map.c

198

threads->nr = total_tasks;

tools/perf/util/thread_map.c

204

if (threads)

tools/perf/util/thread_map.c

205

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.c

206

return threads;

tools/perf/util/thread_map.c

214

zfree(&threads);

tools/perf/util/thread_map.c

220

struct perf_thread_map *threads = NULL, *nt;

tools/perf/util/thread_map.c

244

nt = perf_thread_map__realloc(threads, ntasks);

tools/perf/util/thread_map.c

249

threads = nt;

tools/perf/util/thread_map.c

250

perf_thread_map__set_pid(threads, ntasks - 1, tid);

tools/perf/util/thread_map.c

251

threads->nr = ntasks;

tools/perf/util/thread_map.c

255

if (threads)

tools/perf/util/thread_map.c

256

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.c

257

return threads;

tools/perf/util/thread_map.c

260

zfree(&threads);

tools/perf/util/thread_map.c

275

size_t thread_map__fprintf(struct perf_thread_map *threads, FILE *fp)

tools/perf/util/thread_map.c

279

threads->nr, threads->nr > 1 ? "s" : "");

tools/perf/util/thread_map.c

280

for (i = 0; i < threads->nr; ++i)

tools/perf/util/thread_map.c

281

printed += fprintf(fp, "%s%d", i ? ", " : "", perf_thread_map__pid(threads, i));

tools/perf/util/thread_map.c

331

void thread_map__read_comms(struct perf_thread_map *threads)

tools/perf/util/thread_map.c

335

for (i = 0; i < threads->nr; ++i)

tools/perf/util/thread_map.c

336

comm_init(threads, i);

tools/perf/util/thread_map.c

339

static void thread_map__copy_event(struct perf_thread_map *threads,

tools/perf/util/thread_map.c

344

threads->nr = (int) event->nr;

tools/perf/util/thread_map.c

347

perf_thread_map__set_pid(threads, i, (pid_t) event->entries[i].pid);

tools/perf/util/thread_map.c

348

threads->map[i].comm = strndup(event->entries[i].comm, 16);

tools/perf/util/thread_map.c

351

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.c

356

struct perf_thread_map *threads;

tools/perf/util/thread_map.c

358

threads = thread_map__alloc(event->nr);

tools/perf/util/thread_map.c

359

if (threads)

tools/perf/util/thread_map.c

36

struct perf_thread_map *threads;

tools/perf/util/thread_map.c

360

thread_map__copy_event(threads, event);

tools/perf/util/thread_map.c

362

return threads;

tools/perf/util/thread_map.c

365

bool thread_map__has(struct perf_thread_map *threads, pid_t pid)

tools/perf/util/thread_map.c

369

for (i = 0; i < threads->nr; ++i) {

tools/perf/util/thread_map.c

370

if (threads->map[i].pid == pid)

tools/perf/util/thread_map.c

377

int thread_map__remove(struct perf_thread_map *threads, int idx)

tools/perf/util/thread_map.c

381

if (threads->nr < 1)

tools/perf/util/thread_map.c

384

if (idx >= threads->nr)

tools/perf/util/thread_map.c

390

zfree(&threads->map[idx].comm);

tools/perf/util/thread_map.c

392

for (i = idx; i < threads->nr - 1; i++)

tools/perf/util/thread_map.c

393

threads->map[i] = threads->map[i + 1];

tools/perf/util/thread_map.c

395

threads->nr--;

tools/perf/util/thread_map.c

47

threads = thread_map__alloc(items);

tools/perf/util/thread_map.c

48

if (threads != NULL) {

tools/perf/util/thread_map.c

50

perf_thread_map__set_pid(threads, i, atoi(namelist[i]->d_name));

tools/perf/util/thread_map.c

51

threads->nr = items;

tools/perf/util/thread_map.c

52

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.c

59

return threads;

tools/perf/util/thread_map.c

64

struct perf_thread_map *threads = thread_map__alloc(1);

tools/perf/util/thread_map.c

66

if (threads != NULL) {

tools/perf/util/thread_map.c

67

perf_thread_map__set_pid(threads, 0, tid);

tools/perf/util/thread_map.c

68

threads->nr = 1;

tools/perf/util/thread_map.c

69

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.c

72

return threads;

tools/perf/util/thread_map.c

81

struct perf_thread_map *threads = thread_map__alloc(max_threads);

tools/perf/util/thread_map.c

83

if (threads == NULL)

tools/perf/util/thread_map.c

90

threads->nr = 0;

tools/perf/util/thread_map.c

91

refcount_set(&threads->refcnt, 1);

tools/perf/util/thread_map.h

22

size_t thread_map__fprintf(struct perf_thread_map *threads, FILE *fp);

tools/perf/util/thread_map.h

24

void thread_map__read_comms(struct perf_thread_map *threads);

tools/perf/util/thread_map.h

25

bool thread_map__has(struct perf_thread_map *threads, pid_t pid);

tools/perf/util/thread_map.h

26

int thread_map__remove(struct perf_thread_map *threads, int idx);

tools/perf/util/threads.c

109

struct thread *threads__findnew(struct threads *threads, pid_t pid, pid_t tid, bool *created)

tools/perf/util/threads.c

111

struct threads_table_entry *table = threads__table(threads, tid);

tools/perf/util/threads.c

135

void threads__remove_all_threads(struct threads *threads)

tools/perf/util/threads.c

138

struct threads_table_entry *table = &threads->table[i];

tools/perf/util/threads.c

154

void threads__remove(struct threads *threads, struct thread *thread)

tools/perf/util/threads.c

156

struct threads_table_entry *table = threads__table(threads, thread__tid(thread));

tools/perf/util/threads.c

168

int threads__for_each_thread(struct threads *threads,

tools/perf/util/threads.c

173

struct threads_table_entry *table = &threads->table[i];

tools/perf/util/threads.c

23

void threads__init(struct threads *threads)

tools/perf/util/threads.c

26

struct threads_table_entry *table = &threads->table[i];

tools/perf/util/threads.c

34

void threads__exit(struct threads *threads)

tools/perf/util/threads.c

36

threads__remove_all_threads(threads);

tools/perf/util/threads.c

38

struct threads_table_entry *table = &threads->table[i];

tools/perf/util/threads.c

45

size_t threads__nr(struct threads *threads)

tools/perf/util/threads.c

50

struct threads_table_entry *table = &threads->table[i];

tools/perf/util/threads.c

6

static struct threads_table_entry *threads__table(struct threads *threads, pid_t tid)

tools/perf/util/threads.c

9

return &threads->table[(unsigned int)tid % THREADS__TABLE_SIZE];

tools/perf/util/threads.c

92

struct thread *threads__find(struct threads *threads, pid_t tid)

tools/perf/util/threads.c

94

struct threads_table_entry *table = threads__table(threads, tid);

tools/perf/util/threads.h

24

void threads__init(struct threads *threads);

tools/perf/util/threads.h

25

void threads__exit(struct threads *threads);

tools/perf/util/threads.h

26

size_t threads__nr(struct threads *threads);

tools/perf/util/threads.h

27

struct thread *threads__find(struct threads *threads, pid_t tid);

tools/perf/util/threads.h

28

struct thread *threads__findnew(struct threads *threads, pid_t pid, pid_t tid, bool *created);

tools/perf/util/threads.h

29

void threads__remove_all_threads(struct threads *threads);

tools/perf/util/threads.h

30

void threads__remove(struct threads *threads, struct thread *thread);

tools/perf/util/threads.h

31

int threads__for_each_thread(struct threads *threads,

tools/perf/util/tool_pmu.c

223

struct perf_thread_map *threads,

tools/perf/util/tool_pmu.c

242

nthreads = perf_thread_map__nr(threads);

tools/perf/util/tool_pmu.c

246

pid = perf_thread_map__pid(threads, thread);

tools/perf/util/tool_pmu.c

292

threads->err_thread = thread;

tools/perf/util/tool_pmu.h

57

struct perf_thread_map *threads,

tools/perf/util/values.c

106

values->threads = i + 1;

tools/perf/util/values.c

122

for (int i = 0; i < values->threads; i++) {

tools/perf/util/values.c

201

for (i = 0; i < values->threads; i++) {

tools/perf/util/values.c

222

for (i = 0; i < values->threads; i++) {

tools/perf/util/values.c

23

values->threads = 0;

tools/perf/util/values.c

245

for (i = 0; i < values->threads; i++) {

tools/perf/util/values.c

261

for (i = 0; i < values->threads; i++) {

tools/perf/util/values.c

273

for (i = 0; i < values->threads; i++)

tools/perf/util/values.c

51

for (i = 0; i < values->threads; i++)

tools/perf/util/values.c

87

for (i = 0; i < values->threads; i++)

tools/perf/util/values.c

91

if (values->threads == values->threads_max) {

tools/perf/util/values.c

97

i = values->threads;

tools/perf/util/values.h

11

int threads;

tools/power/cpupower/lib/cpupower.h

11

unsigned int threads; /* per core */

tools/power/x86/turbostat/turbostat.c

2187

#define ODD_COUNTERS odd.threads, odd.cores, odd.packages

tools/power/x86/turbostat/turbostat.c

2188

#define EVEN_COUNTERS even.threads, even.cores, even.packages

tools/power/x86/turbostat/turbostat.c

2372

struct thread_data *threads;

tools/power/x86/turbostat/turbostat.c

3311

if (t == average.threads) {

tools/power/x86/turbostat/turbostat.c

3325

if ((t != average.threads) && (cpu_subset && !CPU_ISSET_S(t->cpu_id, cpu_subset_size, cpu_subset)))

tools/power/x86/turbostat/turbostat.c

3345

if (t == average.threads) {

tools/power/x86/turbostat/turbostat.c

3724

if (DO_BIC(BIC_SysWatt) && (t == average.threads))

tools/power/x86/turbostat/turbostat.c

3726

if (DO_BIC(BIC_Sys_J) && (t == average.threads))

tools/power/x86/turbostat/turbostat.c

3765

format_counters(average.threads, average.cores, average.packages);

tools/power/x86/turbostat/turbostat.c

4169

average.threads->apic_id = t->apic_id;

tools/power/x86/turbostat/turbostat.c

4171

average.threads->x2apic_id = t->x2apic_id;

tools/power/x86/turbostat/turbostat.c

4174

if (average.threads->tv_begin.tv_sec == 0)

tools/power/x86/turbostat/turbostat.c

4175

average.threads->tv_begin = procsysfs_tv_begin;

tools/power/x86/turbostat/turbostat.c

4178

average.threads->tv_end = t->tv_end;

tools/power/x86/turbostat/turbostat.c

4180

average.threads->tsc += t->tsc;

tools/power/x86/turbostat/turbostat.c

4181

average.threads->aperf += t->aperf;

tools/power/x86/turbostat/turbostat.c

4182

average.threads->mperf += t->mperf;

tools/power/x86/turbostat/turbostat.c

4183

average.threads->c1 += t->c1;

tools/power/x86/turbostat/turbostat.c

4185

average.threads->instr_count += t->instr_count;

tools/power/x86/turbostat/turbostat.c

4187

average.threads->irq_count += t->irq_count;

tools/power/x86/turbostat/turbostat.c

4188

average.threads->nmi_count += t->nmi_count;

tools/power/x86/turbostat/turbostat.c

4189

average.threads->smi_count += t->smi_count;

tools/power/x86/turbostat/turbostat.c

4191

average.threads->llc.references += t->llc.references;

tools/power/x86/turbostat/turbostat.c

4192

average.threads->llc.misses += t->llc.misses;

tools/power/x86/turbostat/turbostat.c

4194

average.threads->l2.references += t->l2.references;

tools/power/x86/turbostat/turbostat.c

4195

average.threads->l2.hits += t->l2.hits;

tools/power/x86/turbostat/turbostat.c

4200

average.threads->counter[i] += t->counter[i];

tools/power/x86/turbostat/turbostat.c

4206

average.threads->perf_counter[i] += t->perf_counter[i];

tools/power/x86/turbostat/turbostat.c

4210

average.threads->pmt_counter[i] += t->pmt_counter[i];

tools/power/x86/turbostat/turbostat.c

4321

clear_counters(average.threads, average.cores, average.packages);

tools/power/x86/turbostat/turbostat.c

4326

average.threads->tv_delta = tv_delta;

tools/power/x86/turbostat/turbostat.c

4328

average.threads->tsc /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4329

average.threads->aperf /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4330

average.threads->mperf /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4331

average.threads->instr_count /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4332

average.threads->c1 /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4334

if (average.threads->irq_count > 9999999)

tools/power/x86/turbostat/turbostat.c

4336

if (average.threads->nmi_count > 9999999)

tools/power/x86/turbostat/turbostat.c

4370

if (average.threads->counter[i] > 9999999)

tools/power/x86/turbostat/turbostat.c

4374

average.threads->counter[i] /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4399

if (average.threads->perf_counter[i] > 9999999)

tools/power/x86/turbostat/turbostat.c

4403

average.threads->perf_counter[i] /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

4425

average.threads->pmt_counter[i] /= topo.allowed_cpus;

tools/power/x86/turbostat/turbostat.c

5957

free(even.threads);

tools/power/x86/turbostat/turbostat.c

5961

even.threads = NULL;

tools/power/x86/turbostat/turbostat.c

5965

free(odd.threads);

tools/power/x86/turbostat/turbostat.c

5969

odd.threads = NULL;

tools/power/x86/turbostat/turbostat.c

9684

counters->threads = calloc(1, sizeof(struct thread_data));

tools/power/x86/turbostat/turbostat.c

9685

if (counters->threads == NULL)

tools/power/x86/turbostat/turbostat.c

9707

counters->threads = calloc(num_threads, sizeof(struct thread_data));

tools/power/x86/turbostat/turbostat.c

9708

if (counters->threads == NULL)

tools/power/x86/turbostat/turbostat.c

9712

(counters->threads)[i].cpu_id = -1;

tools/testing/radix-tree/idr-test.c

580

pthread_t threads[20];

tools/testing/radix-tree/idr-test.c

583

for (i = 0; i < ARRAY_SIZE(threads); i++)

tools/testing/radix-tree/idr-test.c

584

if (pthread_create(&threads[i], NULL, ida_random_fn, NULL)) {

tools/testing/radix-tree/idr-test.c

590

pthread_join(threads[i], NULL);

tools/testing/radix-tree/idr-test.c

592

for (i = 0; i < ARRAY_SIZE(threads); i++)

tools/testing/radix-tree/idr-test.c

593

if (pthread_create(&threads[i], NULL, ida_leak_fn, &ida)) {

tools/testing/radix-tree/idr-test.c

599

pthread_join(threads[i], NULL);

tools/testing/radix-tree/iteration_check.c

15

static pthread_t threads[NUM_THREADS];

tools/testing/radix-tree/iteration_check.c

178

if (pthread_create(&threads[0], NULL, tagged_iteration_fn, NULL)) {

tools/testing/radix-tree/iteration_check.c

182

if (pthread_create(&threads[1], NULL, untagged_iteration_fn, NULL)) {

tools/testing/radix-tree/iteration_check.c

186

if (pthread_create(&threads[2], NULL, add_entries_fn, NULL)) {

tools/testing/radix-tree/iteration_check.c

190

if (pthread_create(&threads[3], NULL, remove_entries_fn, NULL)) {

tools/testing/radix-tree/iteration_check.c

194

if (pthread_create(&threads[4], NULL, tag_entries_fn, NULL)) {

tools/testing/radix-tree/iteration_check.c

203

if (pthread_join(threads[i], NULL)) {

tools/testing/radix-tree/iteration_check_2.c

56

pthread_t threads[2];

tools/testing/radix-tree/iteration_check_2.c

67

if (pthread_create(&threads[0], NULL, iterator, &array)) {

tools/testing/radix-tree/iteration_check_2.c

71

if (pthread_create(&threads[1], NULL, throbber, &array)) {

tools/testing/radix-tree/iteration_check_2.c

80

if (pthread_join(threads[i], NULL)) {

tools/testing/radix-tree/regression1.c

168

static pthread_t *threads;

tools/testing/radix-tree/regression1.c

180

threads = malloc(nr_threads * sizeof(*threads));

tools/testing/radix-tree/regression1.c

184

if (pthread_create(&threads[i], NULL, regression1_fn, (void *)arg)) {

tools/testing/radix-tree/regression1.c

191

if (pthread_join(threads[i], NULL)) {

tools/testing/radix-tree/regression1.c

197

free(threads);

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

109

threads = calloc(env.producer_cnt, sizeof(*threads));

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

111

if (!threads) {

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

117

struct thread *t = &threads[i];

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

148

struct thread *t = &threads[(long)(input)];

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

175

struct thread *t = &threads[(long)(input)];

tools/testing/selftests/bpf/benchs/bench_local_storage_create.c

19

static struct thread *threads;

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

201

pthread_t threads[N_THREADS];

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

205

for (i = 0; i < ARRAY_SIZE(threads); i++) {

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

206

ret = pthread_create(&i[threads], NULL, patch_map_thread, opts);

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

210

for (i = 0; i < ARRAY_SIZE(threads); i++) {

tools/testing/selftests/bpf/map_tests/map_percpu_stats.c

211

ret = pthread_join(i[threads], NULL);

tools/testing/selftests/bpf/prog_tests/send_signal_sched_switch.c

32

pthread_t threads[THREAD_COUNT];

tools/testing/selftests/bpf/prog_tests/send_signal_sched_switch.c

50

err = pthread_create(threads + i, NULL, worker, NULL);

tools/testing/selftests/bpf/prog_tests/send_signal_sched_switch.c

57

pthread_join(threads[i], NULL);

tools/testing/selftests/bpf/prog_tests/timer.c

100

pthread_t threads[NUM_THR];

tools/testing/selftests/bpf/prog_tests/timer.c

108

pthread_create(&threads[i], NULL, nmi_cpu_worker, NULL);

tools/testing/selftests/bpf/prog_tests/timer.c

110

pthread_join(threads[i], NULL);

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

104

pthread_t threads[2];

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

114

err = pthread_create(&threads[0], NULL, start_timer_thread, &ctx);

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

120

err = pthread_create(&threads[1], NULL, delete_elem_thread, &ctx);

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

123

pthread_join(threads[0], NULL);

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

129

pthread_join(threads[0], NULL);

tools/testing/selftests/bpf/prog_tests/timer_start_delete_race.c

130

pthread_join(threads[1], NULL);

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c

728

pthread_t *threads;

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c

735

threads = alloca(sizeof(*threads) * nr_threads);

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c

736

if (!ASSERT_OK_PTR(threads, "malloc"))

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c

740

err = pthread_create(&threads[i], NULL, i % 2 ? worker_trigger : worker_attach,

tools/testing/selftests/bpf/prog_tests/uprobe_syscall.c

751

pthread_join(threads[i], NULL);

tools/testing/selftests/cgroup/test_core.c

580

pthread_t threads[n_threads];

tools/testing/selftests/cgroup/test_core.c

596

if (pthread_create(&threads[c_threads], NULL, dummy_thread_fn, NULL))

tools/testing/selftests/cgroup/test_core.c

608

pthread_cancel(threads[t]);

tools/testing/selftests/cgroup/test_core.c

612

pthread_join(threads[t], NULL);

tools/testing/selftests/drivers/ntsync/ntsync.c

1308

pthread_t threads[STRESS_THREADS];

tools/testing/selftests/drivers/ntsync/ntsync.c

1326

pthread_create(&threads[i], NULL, stress_thread, NULL);

tools/testing/selftests/drivers/ntsync/ntsync.c

1332

ret = pthread_join(threads[i], NULL);

tools/testing/selftests/filesystems/binderfs/binderfs_test.c

406

pthread_t threads[DEFAULT_THREADS];

tools/testing/selftests/filesystems/binderfs/binderfs_test.c

462

ret = pthread_create(&threads[i], &attr, binder_version_thread, INT_TO_PTR(fds[k]));

tools/testing/selftests/filesystems/binderfs/binderfs_test.c

473

ret = pthread_join(threads[j], &fdptr);

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3364

pthread_t threads[3];

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3380

ASSERT_EQ(pthread_create(&threads[0], NULL,

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3382

ASSERT_EQ(pthread_create(&threads[1], NULL,

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3384

ASSERT_EQ(pthread_create(&threads[2], NULL,

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3387

for (n = 0; n < ARRAY_SIZE(threads); ++n)

tools/testing/selftests/filesystems/epoll/epoll_wakeup_test.c

3388

ASSERT_EQ(pthread_join(threads[n], NULL), 0);

tools/testing/selftests/futex/functional/futex_numa.c

165

int c, t, threads = 2, contenders = 0;

tools/testing/selftests/futex/functional/futex_numa.c

175

threads = atoi(optarg);

tools/testing/selftests/futex/functional/futex_numa.c

215

for (t = 0; t < threads; t++) {

tools/testing/selftests/futex/functional/futex_numa.c

240

for (t = 0; t < threads; t++) {

tools/testing/selftests/futex/functional/futex_numa_mpol.c

26

static pthread_t threads[MAX_THREADS];

tools/testing/selftests/futex/functional/futex_numa_mpol.c

63

ret = pthread_create(&threads[i], NULL, thread_lock_fn, &thread_args[i]);

tools/testing/selftests/futex/functional/futex_numa_mpol.c

74

ret = pthread_join(threads[i], NULL);

tools/testing/selftests/futex/functional/futex_priv_hash.c

101

ret = pthread_join(threads[i], NULL);

tools/testing/selftests/futex/functional/futex_priv_hash.c

152

ret = pthread_create(&threads[0], NULL, thread_return_fn, NULL);

tools/testing/selftests/futex/functional/futex_priv_hash.c

156

ret = pthread_join(threads[0], NULL);

tools/testing/selftests/futex/functional/futex_priv_hash.c

23

static pthread_t threads[MAX_THREADS];

tools/testing/selftests/futex/functional/futex_priv_hash.c

90

ret = pthread_create(&threads[i], NULL, thread_fn, NULL);

tools/testing/selftests/kvm/hardware_disable_test.c

103

check_create_thread(&threads[i], NULL, run_vcpu, vcpu);

tools/testing/selftests/kvm/hardware_disable_test.c

104

check_set_affinity(threads[i], &cpu_set);

tools/testing/selftests/kvm/hardware_disable_test.c

115

check_join(threads[i], &b);

tools/testing/selftests/kvm/hardware_disable_test.c

88

pthread_t threads[VCPU_NUM];

tools/testing/selftests/kvm/mmu_stress_test.c

210

pthread_t *threads;

tools/testing/selftests/kvm/mmu_stress_test.c

213

threads = malloc(nr_vcpus * sizeof(*threads));

tools/testing/selftests/kvm/mmu_stress_test.c

214

TEST_ASSERT(threads, "Failed to allocate vCPU threads");

tools/testing/selftests/kvm/mmu_stress_test.c

227

pthread_create(&threads[i], NULL, vcpu_worker, &info[i]);

tools/testing/selftests/kvm/mmu_stress_test.c

229

return threads;

tools/testing/selftests/kvm/mmu_stress_test.c

289

pthread_t *threads;

tools/testing/selftests/kvm/mmu_stress_test.c

372

threads = spawn_workers(vm, vcpus, start_gpa, gpa);

tools/testing/selftests/kvm/mmu_stress_test.c

419

pthread_join(threads[i], NULL);

tools/testing/selftests/kvm/x86/hyperv_ipi.c

247

pthread_t threads[2];

tools/testing/selftests/kvm/x86/hyperv_ipi.c

275

r = pthread_create(&threads[0], NULL, vcpu_thread, vcpu[1]);

tools/testing/selftests/kvm/x86/hyperv_ipi.c

278

r = pthread_create(&threads[1], NULL, vcpu_thread, vcpu[2]);

tools/testing/selftests/kvm/x86/hyperv_ipi.c

305

cancel_join_vcpu_thread(threads[0], vcpu[1]);

tools/testing/selftests/kvm/x86/hyperv_ipi.c

306

cancel_join_vcpu_thread(threads[1], vcpu[2]);

tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c

583

pthread_t threads[2];

tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c

646

r = pthread_create(&threads[0], NULL, vcpu_thread, vcpu[1]);

tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c

649

r = pthread_create(&threads[1], NULL, vcpu_thread, vcpu[2]);

tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c

675

cancel_join_vcpu_thread(threads[0], vcpu[1]);

tools/testing/selftests/kvm/x86/hyperv_tlb_flush.c

676

cancel_join_vcpu_thread(threads[1], vcpu[2]);

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

381

pthread_t threads[KVM_MAX_VCPUS];

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

415

pthread_create(&threads[i], NULL, __test_mem_conversions, vcpus[i]);

tools/testing/selftests/kvm/x86/private_mem_conversions_test.c

421

pthread_join(threads[i], NULL);

tools/testing/selftests/kvm/x86/xapic_ipi_test.c

398

pthread_t threads[2];

tools/testing/selftests/kvm/x86/xapic_ipi_test.c

431

r = pthread_create(&threads[0], NULL, vcpu_thread, &params[0]);

tools/testing/selftests/kvm/x86/xapic_ipi_test.c

450

r = pthread_create(&threads[1], NULL, vcpu_thread, &params[1]);

tools/testing/selftests/kvm/x86/xapic_ipi_test.c

465

cancel_join_vcpu_thread(threads[0], params[0].vcpu);

tools/testing/selftests/kvm/x86/xapic_ipi_test.c

466

cancel_join_vcpu_thread(threads[1], params[1].vcpu);

tools/testing/selftests/landlock/tsync_test.c

205

pthread_t threads[NUM_IDLE_THREADS];

tools/testing/selftests/landlock/tsync_test.c

221

ASSERT_EQ(0, pthread_create(&threads[i], NULL, idle, NULL));

tools/testing/selftests/landlock/tsync_test.c

243

ASSERT_EQ(0, pthread_cancel(threads[i]));

tools/testing/selftests/landlock/tsync_test.c

244

ASSERT_EQ(0, pthread_join(threads[i], NULL));

tools/testing/selftests/mm/migration.c

138

if (pthread_create(&self->threads[i], NULL, access_mem, ptr))

tools/testing/selftests/mm/migration.c

143

ASSERT_EQ(pthread_cancel(self->threads[i]), 0);

tools/testing/selftests/mm/migration.c

203

if (pthread_create(&self->threads[i], NULL, access_mem, ptr))

tools/testing/selftests/mm/migration.c

208

ASSERT_EQ(pthread_cancel(self->threads[i]), 0);

tools/testing/selftests/mm/migration.c

270

if (pthread_create(&self->threads[i], NULL, access_mem, ptr))

tools/testing/selftests/mm/migration.c

275

ASSERT_EQ(pthread_cancel(self->threads[i]), 0);

tools/testing/selftests/mm/migration.c

28

pthread_t *threads;

tools/testing/selftests/mm/migration.c

54

self->threads = malloc(self->nthreads * sizeof(*self->threads));

tools/testing/selftests/mm/migration.c

55

ASSERT_NE(self->threads, NULL);

tools/testing/selftests/mm/migration.c

62

free(self->threads);

tools/testing/selftests/mount_setattr/mount_setattr_test.c

902

pthread_t threads[DEFAULT_THREADS];

tools/testing/selftests/mount_setattr/mount_setattr_test.c

917

ASSERT_EQ(pthread_create(&threads[i], &pattr, mount_setattr_thread, NULL), 0);

tools/testing/selftests/mount_setattr/mount_setattr_test.c

922

EXPECT_EQ(pthread_join(threads[j], &retptr), 0);

tools/testing/selftests/perf_events/sigtrap_threads.c

113

pthread_t threads[NUM_THREADS];

tools/testing/selftests/perf_events/sigtrap_threads.c

139

ASSERT_EQ(pthread_create(&self->threads[i], NULL, test_thread, &self->barrier), 0);

tools/testing/selftests/perf_events/sigtrap_threads.c

156

ASSERT_EQ(pthread_join(self->threads[i], NULL), 0);

tools/testing/selftests/perf_events/sigtrap_threads.c

232

ASSERT_EQ(pthread_join(self->threads[i], NULL), 0);

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

121

struct random_thread_args threads[THREADS];

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

137

threads[i].expected_system_dscr = &expected_system_dscr;

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

138

threads[i].rw_lock = &rw_lock;

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

139

threads[i].barrier = &barrier;

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

141

FAIL_IF(pthread_create(&threads[i].thread_id, NULL,

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

142

dscr_default_random_thread, (void *)&threads[i]));

tools/testing/selftests/powerpc/dscr/dscr_default_test.c

146

FAIL_IF(pthread_join(threads[i].thread_id, NULL));

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

135

struct random_thread_args threads[THREADS];

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

143

threads[i].do_yields = i % 2 == 0;

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

144

threads[i].barrier = &barrier;

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

146

FAIL_IF(pthread_create(&threads[i].thread_id, NULL,

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

147

dscr_explicit_random_thread, (void *)&threads[i]));

tools/testing/selftests/powerpc/dscr/dscr_explicit_test.c

151

FAIL_IF(pthread_join(threads[i].thread_id, NULL));

tools/testing/selftests/powerpc/math/fpu_preempt.c

53

int i, rc, threads;

tools/testing/selftests/powerpc/math/fpu_preempt.c

56

threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;

tools/testing/selftests/powerpc/math/fpu_preempt.c

57

tids = malloc((threads) * sizeof(pthread_t));

tools/testing/selftests/powerpc/math/fpu_preempt.c

61

threads_starting = threads;

tools/testing/selftests/powerpc/math/fpu_preempt.c

62

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/fpu_preempt.c

84

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/fpu_signal.c

105

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/fpu_signal.c

73

int i, j, rc, threads;

tools/testing/selftests/powerpc/math/fpu_signal.c

77

threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;

tools/testing/selftests/powerpc/math/fpu_signal.c

78

tids = malloc(threads * sizeof(pthread_t));

tools/testing/selftests/powerpc/math/fpu_signal.c

82

threads_starting = threads;

tools/testing/selftests/powerpc/math/fpu_signal.c

83

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/fpu_signal.c

96

for (j = 0; j < threads; j++) {

tools/testing/selftests/powerpc/math/vmx_preempt.c

59

int i, rc, threads;

tools/testing/selftests/powerpc/math/vmx_preempt.c

65

threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;

tools/testing/selftests/powerpc/math/vmx_preempt.c

66

tids = malloc(threads * sizeof(pthread_t));

tools/testing/selftests/powerpc/math/vmx_preempt.c

70

threads_starting = threads;

tools/testing/selftests/powerpc/math/vmx_preempt.c

71

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vmx_preempt.c

93

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vmx_signal.c

102

threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;

tools/testing/selftests/powerpc/math/vmx_signal.c

103

tids = malloc(threads * sizeof(pthread_t));

tools/testing/selftests/powerpc/math/vmx_signal.c

107

threads_starting = threads;

tools/testing/selftests/powerpc/math/vmx_signal.c

108

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vmx_signal.c

114

printf("\tWaiting for %d workers to start... %d", threads, threads_starting);

tools/testing/selftests/powerpc/math/vmx_signal.c

124

for (j = 0; j < threads; j++) {

tools/testing/selftests/powerpc/math/vmx_signal.c

133

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vmx_signal.c

95

int i, j, rc, threads;

tools/testing/selftests/powerpc/math/vsx_preempt.c

102

threads_starting = threads;

tools/testing/selftests/powerpc/math/vsx_preempt.c

103

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vsx_preempt.c

125

for (i = 0; i < threads; i++) {

tools/testing/selftests/powerpc/math/vsx_preempt.c

92

int i, rc, threads;

tools/testing/selftests/powerpc/math/vsx_preempt.c

97

threads = sysconf(_SC_NPROCESSORS_ONLN) * THREAD_FACTOR;

tools/testing/selftests/powerpc/math/vsx_preempt.c

98

tids = malloc(threads * sizeof(pthread_t));

tools/testing/selftests/powerpc/signal/sigfuz.c

252

pthread_t *threads;

tools/testing/selftests/powerpc/signal/sigfuz.c

254

threads = malloc(nthread * sizeof(pthread_t));

tools/testing/selftests/powerpc/signal/sigfuz.c

257

rc = pthread_create(&threads[t], NULL, sigfuz_test,

tools/testing/selftests/powerpc/signal/sigfuz.c

264

rc = pthread_join(threads[t], NULL);

tools/testing/selftests/powerpc/signal/sigfuz.c

269

free(threads);

tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c

103

for (uint64_t i = 0; i < threads; i++)

tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c

106

for (uint64_t i = 0; i < threads; i++)

tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c

90

int threads;

tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c

98

threads = sysconf(_SC_NPROCESSORS_ONLN) * 4;

tools/testing/selftests/powerpc/tm/tm-vmx-unavail.c

99

thread = malloc(sizeof(pthread_t)*threads);

tools/testing/selftests/sched_ext/reload_loop.c

15

static pthread_t threads[2];

tools/testing/selftests/sched_ext/reload_loop.c

49

err = pthread_create(&threads[0], NULL, do_reload_loop, NULL);

tools/testing/selftests/sched_ext/reload_loop.c

52

err = pthread_create(&threads[1], NULL, do_reload_loop, NULL);

tools/testing/selftests/sched_ext/reload_loop.c

55

SCX_FAIL_IF(pthread_join(threads[0], &ret), "thread 0 failed");

tools/testing/selftests/sched_ext/reload_loop.c

56

SCX_FAIL_IF(pthread_join(threads[1], &ret), "thread 1 failed");

tools/testing/selftests/sched_ext/total_bw.c

47

pthread_t *threads;

tools/testing/selftests/sched_ext/total_bw.c

50

threads = calloc(nr_cpus, sizeof(pthread_t));

tools/testing/selftests/sched_ext/total_bw.c

51

if (!threads)

tools/testing/selftests/sched_ext/total_bw.c

56

if (pthread_create(&threads[i], NULL, cpu_stress_thread, NULL)) {

tools/testing/selftests/sched_ext/total_bw.c

65

if (threads[i])

tools/testing/selftests/sched_ext/total_bw.c

66

pthread_join(threads[i], NULL);

tools/testing/selftests/sched_ext/total_bw.c

69

free(threads);

tools/testing/selftests/sync/sync_stress_consumer.c

112

int n = test_data_mpsc.threads;

tools/testing/selftests/sync/sync_stress_consumer.c

160

pthread_t threads[n];

tools/testing/selftests/sync/sync_stress_consumer.c

169

test_data_mpsc.threads = n;

tools/testing/selftests/sync/sync_stress_consumer.c

174

pthread_create(&threads[i], NULL, (void * (*)(void *))

tools/testing/selftests/sync/sync_stress_consumer.c

182

pthread_join(threads[i], NULL);

tools/testing/selftests/sync/sync_stress_consumer.c

56

int threads;

tools/testing/selftests/vDSO/vdso_test_getrandom.c

202

pthread_t threads[THREADS];

tools/testing/selftests/vDSO/vdso_test_getrandom.c

206

ksft_assert(pthread_create(&threads[i], NULL, test_vdso_getrandom, NULL) == 0);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

208

pthread_join(threads[i], NULL);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

215

ksft_assert(pthread_create(&threads[i], NULL, test_libc_getrandom, NULL) == 0);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

217

pthread_join(threads[i], NULL);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

224

ksft_assert(pthread_create(&threads[i], NULL, test_syscall_getrandom, NULL) == 0);

tools/testing/selftests/vDSO/vdso_test_getrandom.c

226

pthread_join(threads[i], NULL);

tools/testing/selftests/vfio/vfio_pci_device_init_perf_test.c

125

pthread_create(&self->threads[i], NULL, thread_main,

tools/testing/selftests/vfio/vfio_pci_device_init_perf_test.c

133

pthread_join(self->threads[i], NULL);

tools/testing/selftests/vfio/vfio_pci_device_init_perf_test.c

26

pthread_t *threads;

tools/testing/selftests/vfio/vfio_pci_device_init_perf_test.c

48

self->threads = calloc(nr_devices, sizeof(self->threads[0]));

tools/testing/selftests/vfio/vfio_pci_device_init_perf_test.c

63

free(self->threads);

tools/usb/ffs-test.c

357

} threads[] = {

tools/usb/ffs-test.c

399

if (t != threads) {

tools/usb/ffs-test.c

666

init_thread(threads);

tools/usb/ffs-test.c

667

ep0_init(threads, legacy_descriptors);

tools/usb/ffs-test.c

669

for (i = 1; i < sizeof threads / sizeof *threads; ++i)

tools/usb/ffs-test.c

670

init_thread(threads + i);

tools/usb/ffs-test.c

672

for (i = 1; i < sizeof threads / sizeof *threads; ++i)

tools/usb/ffs-test.c

673

start_thread(threads + i);

tools/usb/ffs-test.c

675

start_thread_helper(threads);

tools/usb/ffs-test.c

677

for (i = 1; i < sizeof threads / sizeof *threads; ++i)

tools/usb/ffs-test.c

678

join_thread(threads + i);