[PATCH v2 2/4] Transform thread_map to linked list

From: chenggang
Date: Tue Feb 26 2013 - 04:21:56 EST

From: chenggang <chenggang.qcg@xxxxxxxxxx>

The size of thread_map is fixed at initialized phase according to the
files in /proc/{$pid}. It cannot be expanded and shrinked easily while we
want to response the thread fork and exit events.
We transform the thread_map structure to a linked list, and implement some
interfaces to expend and shrink it. In order to improve compatibility with
the existing code, we can get a thread by its index in the thread_map also.
1) thread_map__append()
Append a new thread into thread_map according to new thread's pid.
2) thread_map__remove()
Remove a exist thread from thread_map according to the index of the
thread in thread_map.
3) thread_map__init()
Allocate a thread_map, and initialize it. But the thread_map is empty after
we called this function. We should call thread_map__append() to insert
threads.
4) thread_map__delete()
Delete a exist thread_map.
5) thread_map__get_pid()
Got a thread's pid by its index in the thread_map.
6) thread_map__get_idx_by_pid()
Got a thread's index in the thread_map according to its pid.
While we got a PERF_RECORD_EXIT event, we only know the pid of the exited thread.
7) thread_map__empty_thread_map()
Return a empty thread_map, there is only a dumb thread in it.
This function is used to instead of the global varible empty_thread_map.

Cc: David Ahern <dsahern@xxxxxxxxx>
Cc: Peter Zijlstra <a.p.zijlstra@xxxxxxxxx>
Cc: Paul Mackerras <paulus@xxxxxxxxx>
Cc: Ingo Molnar <mingo@xxxxxxxxxx>
Cc: Arnaldo Carvalho de Melo <acme@xxxxxxxxxxxxxxxxxx>
Cc: Arjan van de Ven <arjan@xxxxxxxxxxxxxxx>
Cc: Namhyung Kim <namhyung@xxxxxxxxx>
Cc: Yanmin Zhang <yanmin.zhang@xxxxxxxxx>
Cc: Wu Fengguang <fengguang.wu@xxxxxxxxx>
Cc: Mike Galbraith <efault@xxxxxx>
Cc: Andrew Morton <akpm@xxxxxxxxxxxxxxxxxxxx>
Signed-off-by: Chenggang Qin <chenggang.qcg@xxxxxxxxxx>

---
tools/perf/builtin-stat.c | 2 +-
tools/perf/tests/open-syscall-tp-fields.c | 2 +-
tools/perf/util/event.c | 10 +-
tools/perf/util/evlist.c | 2 +-
tools/perf/util/evsel.c | 16 +--
tools/perf/util/python.c | 2 +-
tools/perf/util/thread_map.c | 210 +++++++++++++++++++----------
tools/perf/util/thread_map.h | 19 ++-
tools/perf/util/xyarray.c | 4 +-
9 files changed, 171 insertions(+), 96 deletions(-)

diff --git a/tools/perf/builtin-stat.c b/tools/perf/builtin-stat.c
index 9984876..f5fe0da 100644
--- a/tools/perf/builtin-stat.c
+++ b/tools/perf/builtin-stat.c
@@ -401,7 +401,7 @@ static int __run_perf_stat(int argc __maybe_unused, const char **argv)
}

if (perf_target__none(&target))
- evsel_list->threads->map[0] = child_pid;
+ thread_map__append(evsel_list->threads, child_pid);

/*
* Wait for the child to be ready to exec.
diff --git a/tools/perf/tests/open-syscall-tp-fields.c b/tools/perf/tests/open-syscall-tp-fields.c
index 1c52fdc..39eb770 100644
--- a/tools/perf/tests/open-syscall-tp-fields.c
+++ b/tools/perf/tests/open-syscall-tp-fields.c
@@ -43,7 +43,7 @@ int test__syscall_open_tp_fields(void)

perf_evsel__config(evsel, &opts);

- evlist->threads->map[0] = getpid();
+ thread_map__append(evlist->threads, getpid());

err = perf_evlist__open(evlist);
if (err < 0) {
diff --git a/tools/perf/util/event.c b/tools/perf/util/event.c
index 5cd13d7..91d2848 100644
--- a/tools/perf/util/event.c
+++ b/tools/perf/util/event.c
@@ -327,8 +327,8 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
err = 0;
for (thread = 0; thread < threads->nr; ++thread) {
if (__event__synthesize_thread(comm_event, mmap_event,
- threads->map[thread], 0,
- process, tool, machine)) {
+ thread_map__get_pid(threads,
+ thread), 0, process, tool,
+ machine)) {
err = -1;
break;
}
@@ -337,12 +337,14 @@ int perf_event__synthesize_thread_map(struct perf_tool *tool,
* comm.pid is set to thread group id by
* perf_event__synthesize_comm
*/
- if ((int) comm_event->comm.pid != threads->map[thread]) {
+ if ((int) comm_event->comm.pid
+ != thread_map__get_pid(threads, thread)) {
bool need_leader = true;

/* is thread group leader in thread_map? */
for (j = 0; j < threads->nr; ++j) {
- if ((int) comm_event->comm.pid == threads->map[j]) {
+ if ((int) comm_event->comm.pid
+ == thread_map__get_pid(threads, thread)) {
need_leader = false;
break;
}
diff --git a/tools/perf/util/evlist.c b/tools/perf/util/evlist.c
index bc4ad79..d5063d6 100644
--- a/tools/perf/util/evlist.c
+++ b/tools/perf/util/evlist.c
@@ -793,7 +793,7 @@ int perf_evlist__prepare_workload(struct perf_evlist *evlist,
}

if (perf_target__none(&opts->target))
- evlist->threads->map[0] = evlist->workload.pid;
+ thread_map__append(evlist->threads, evlist->workload.pid);

close(child_ready_pipe[1]);
close(go_pipe[0]);
diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 9c82f98f..57c569d 100644
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -835,7 +835,7 @@ retry_sample_id:
int group_fd;

if (!evsel->cgrp)
- pid = threads->map[thread];
+ pid = thread_map__get_pid(threads, thread);

group_fd = get_group_fd(evsel, cpu, thread);

@@ -894,14 +894,6 @@ static struct {
.cpus = { -1, },
};

-static struct {
- struct thread_map map;
- int threads[1];
-} empty_thread_map = {
- .map.nr = 1,
- .threads = { -1, },
-};
-
int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
struct thread_map *threads)
{
@@ -911,7 +903,7 @@ int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
}

if (threads == NULL)
- threads = &empty_thread_map.map;
+ threads = thread_map__empty_thread_map();

return __perf_evsel__open(evsel, cpus, threads);
}
@@ -919,7 +911,9 @@ int perf_evsel__open(struct perf_evsel *evsel, struct cpu_map *cpus,
int perf_evsel__open_per_cpu(struct perf_evsel *evsel,
struct cpu_map *cpus)
{
- return __perf_evsel__open(evsel, cpus, &empty_thread_map.map);
+ struct thread_map *empty_thread_map = thread_map__empty_thread_map();
+
+ return __perf_evsel__open(evsel, cpus, empty_thread_map);
}

int perf_evsel__open_per_thread(struct perf_evsel *evsel,
diff --git a/tools/perf/util/python.c b/tools/perf/util/python.c
index 925e0c3..e3f3f1b 100644
--- a/tools/perf/util/python.c
+++ b/tools/perf/util/python.c
@@ -458,7 +458,7 @@ static PyObject *pyrf_thread_map__item(PyObject *obj, Py_ssize_t i)
if (i >= pthreads->threads->nr)
return NULL;

- return Py_BuildValue("i", pthreads->threads->map[i]);
+ return Py_BuildValue("i", thread_map__get_pid(pthreads->threads, i));
}

static PySequenceMethods pyrf_thread_map__sequence_methods = {
diff --git a/tools/perf/util/thread_map.c b/tools/perf/util/thread_map.c
index 9b5f856..5f96fdf 100644
--- a/tools/perf/util/thread_map.c
+++ b/tools/perf/util/thread_map.c
@@ -19,9 +19,72 @@ static int filter(const struct dirent *dir)
return 1;
}

-struct thread_map *thread_map__new_by_pid(pid_t pid)
+struct thread_map *thread_map__init(void)
{
struct thread_map *threads;
+
+ threads = malloc(sizeof(*threads));
+ if (threads == NULL)
+ return NULL;
+
+ threads->nr = 0;
+ INIT_LIST_HEAD(&threads->head);
+ return threads;
+}
+
+void thread_map__delete(struct thread_map *threads)
+{
+ struct thread_pid *tp, *tmp;
+
+ list_for_each_entry_safe(tp, tmp, &threads->head, next) {
+ list_del(&tp->next);
+ free(tp);
+ }
+
+ free(threads);
+}
+
+int thread_map__append(struct thread_map *threads, pid_t pid)
+{
+ struct thread_pid *tp;
+
+ if (threads == NULL)
+ return -1;
+
+ list_for_each_entry(tp, &threads->head, next)
+ if (tp->pid == pid) /*The thread is exist*/
+ return 1;
+
+ tp = malloc(sizeof(*tp));
+ if (tp == NULL)
+ return -1;
+
+ tp->pid = pid;
+ list_add_tail(&tp->next, &threads->head);
+ threads->nr++;
+
+ return 0; /*success*/
+}
+
+int thread_map__remove(struct thread_map *threads, int idx)
+{
+ struct thread_pid *tp;
+ int count = 0;
+
+ list_for_each_entry(tp, &threads->head, next)
+ if (count++ == idx) {
+ list_del(&tp->next);
+ free(tp);
+ threads->nr--;
+ return 0;
+ }
+
+ return -1;
+}
+
+struct thread_map *thread_map__new_by_pid(pid_t pid)
+{
+ struct thread_map *threads = NULL;
char name[256];
int items;
struct dirent **namelist = NULL;
@@ -32,40 +95,49 @@ struct thread_map *thread_map__new_by_pid(pid_t pid)
if (items <= 0)
return NULL;

- threads = malloc(sizeof(*threads) + sizeof(pid_t) * items);
- if (threads != NULL) {
+ threads = thread_map__init();
+ if (threads != NULL)
for (i = 0; i < items; i++)
- threads->map[i] = atoi(namelist[i]->d_name);
- threads->nr = items;
- }
+ if (thread_map__append(threads,
+ atoi(namelist[i]->d_name)) == -1)
+ goto out_free_threads;

for (i=0; i<items; i++)
free(namelist[i]);
free(namelist);

return threads;
+
+out_free_threads:
+ thread_map__delete(threads);
+ return NULL;
}

struct thread_map *thread_map__new_by_tid(pid_t tid)
{
- struct thread_map *threads = malloc(sizeof(*threads) + sizeof(pid_t));
+ struct thread_map *threads = NULL;

- if (threads != NULL) {
- threads->map[0] = tid;
- threads->nr = 1;
- }
+ threads = thread_map__init();
+ if (threads != NULL)
+ if (thread_map__append(threads, tid) == -1)
+ goto out_free_threads;

return threads;
+
+out_free_threads:
+ thread_map__delete(threads);
+ return NULL;
}

struct thread_map *thread_map__new_by_uid(uid_t uid)
{
DIR *proc;
- int max_threads = 32, items, i;
+ int items, i;
char path[256];
struct dirent dirent, *next, **namelist = NULL;
- struct thread_map *threads = malloc(sizeof(*threads) +
- max_threads * sizeof(pid_t));
+ struct thread_map *threads = NULL;
+
+ threads = thread_map__init();
if (threads == NULL)
goto out;

@@ -73,11 +145,8 @@ struct thread_map *thread_map__new_by_uid(uid_t uid)
if (proc == NULL)
goto out_free_threads;

- threads->nr = 0;
-
while (!readdir_r(proc, &dirent, &next) && next) {
char *end;
- bool grow = false;
struct stat st;
pid_t pid = strtol(dirent.d_name, &end, 10);

@@ -97,30 +166,13 @@ struct thread_map *thread_map__new_by_uid(uid_t uid)
if (items <= 0)
goto out_free_closedir;

- while (threads->nr + items >= max_threads) {
- max_threads *= 2;
- grow = true;
- }
-
- if (grow) {
- struct thread_map *tmp;
-
- tmp = realloc(threads, (sizeof(*threads) +
- max_threads * sizeof(pid_t)));
- if (tmp == NULL)
- goto out_free_namelist;
-
- threads = tmp;
- }
-
for (i = 0; i < items; i++)
- threads->map[threads->nr + i] = atoi(namelist[i]->d_name);
+ if (thread_map__append(threads, atoi(namelist[i]->d_name) < 0))
+ goto out_free_namelist;

for (i = 0; i < items; i++)
free(namelist[i]);
free(namelist);
-
- threads->nr += items;
}

out_closedir:
@@ -129,7 +181,7 @@ out:
return threads;

out_free_threads:
- free(threads);
+ thread_map__delete(threads);
return NULL;

out_free_namelist:
@@ -138,7 +190,7 @@ out_free_namelist:
free(namelist);

out_free_closedir:
- free(threads);
+ thread_map__delete(threads);
threads = NULL;
goto out_closedir;
}
@@ -156,11 +208,11 @@ struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid)

static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
{
- struct thread_map *threads = NULL, *nt;
+ struct thread_map *threads = NULL;
char name[256];
- int items, total_tasks = 0;
+ int items;
struct dirent **namelist = NULL;
- int i, j = 0;
+ int i;
pid_t pid, prev_pid = INT_MAX;
char *end_ptr;
struct str_node *pos;
@@ -169,6 +221,10 @@ static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
if (!slist)
return NULL;

+ threads = thread_map__init();
+ if (threads == NULL)
+ return NULL;
+
strlist__for_each(pos, slist) {
pid = strtol(pos->s, &end_ptr, 10);

@@ -184,19 +240,12 @@ static struct thread_map *thread_map__new_by_pid_str(const char *pid_str)
if (items <= 0)
goto out_free_threads;

- total_tasks += items;
- nt = realloc(threads, (sizeof(*threads) +
- sizeof(pid_t) * total_tasks));
- if (nt == NULL)
- goto out_free_namelist;
-
- threads = nt;
+ for (i = 0; i < items; i++)
+ if (thread_map__append(threads, atoi(namelist[i]->d_name)) < 0)
+ goto out_free_namelist;

- for (i = 0; i < items; i++) {
- threads->map[j++] = atoi(namelist[i]->d_name);
+ for (i = 0; i < items; i++)
free(namelist[i]);
- }
- threads->nr = total_tasks;
free(namelist);
}

@@ -210,15 +259,14 @@ out_free_namelist:
free(namelist);

out_free_threads:
- free(threads);
+ thread_map__delete(threads);
threads = NULL;
goto out;
}

static struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
{
- struct thread_map *threads = NULL, *nt;
- int ntasks = 0;
+ struct thread_map *threads = NULL;
pid_t tid, prev_tid = INT_MAX;
char *end_ptr;
struct str_node *pos;
@@ -226,14 +274,16 @@ static struct thread_map *thread_map__new_by_tid_str(const char *tid_str)

/* perf-stat expects threads to be generated even if tid not given */
if (!tid_str) {
- threads = malloc(sizeof(*threads) + sizeof(pid_t));
- if (threads != NULL) {
- threads->map[0] = -1;
- threads->nr = 1;
- }
+ threads = thread_map__init();
+ if (threads != NULL)
+ thread_map__append(threads, -1);
return threads;
}

+ threads = thread_map__init();
+ if (!threads)
+ goto out;
+
slist = strlist__new(false, tid_str);
if (!slist)
return NULL;
@@ -248,21 +298,14 @@ static struct thread_map *thread_map__new_by_tid_str(const char *tid_str)
if (tid == prev_tid)
continue;

- ntasks++;
- nt = realloc(threads, sizeof(*threads) + sizeof(pid_t) * ntasks);
-
- if (nt == NULL)
+ if (thread_map__append(threads, tid) == -1)
goto out_free_threads;
-
- threads = nt;
- threads->map[ntasks - 1] = tid;
- threads->nr = ntasks;
}
out:
return threads;

out_free_threads:
- free(threads);
+ thread_map__delete(threads);
threads = NULL;
goto out;
}
@@ -279,18 +322,37 @@ struct thread_map *thread_map__new_str(const char *pid, const char *tid,
return thread_map__new_by_tid_str(tid);
}

-void thread_map__delete(struct thread_map *threads)
+struct thread_map *thread_map__empty_thread_map(void)
{
- free(threads);
+ struct thread_map *empty_thread_map = NULL;
+
+ empty_thread_map = thread_map__init();
+ if (empty_thread_map)
+ thread_map__append(empty_thread_map, -1);
+
+ return empty_thread_map;
+}
+
+int thread_map__get_pid(struct thread_map *threads, int idx)
+{
+ struct thread_pid *tp;
+ int count = 0;
+
+ list_for_each_entry(tp, &threads->head, next)
+ if (count++ == idx)
+ return tp->pid;
+
+ return -1;
}

size_t thread_map__fprintf(struct thread_map *threads, FILE *fp)
{
- int i;
+ int i = 0;
+ struct thread_pid *tp;
size_t printed = fprintf(fp, "%d thread%s: ",
threads->nr, threads->nr > 1 ? "s" : "");
- for (i = 0; i < threads->nr; ++i)
- printed += fprintf(fp, "%s%d", i ? ", " : "", threads->map[i]);
+ list_for_each_entry(tp, &threads->head, next)
+ printed += fprintf(fp, "%s%d", i++ ? ", " : "", tp->pid);

return printed + fprintf(fp, "\n");
}
diff --git a/tools/perf/util/thread_map.h b/tools/perf/util/thread_map.h
index f718df8..e5a3013 100644
--- a/tools/perf/util/thread_map.h
+++ b/tools/perf/util/thread_map.h
@@ -3,20 +3,37 @@

#include <sys/types.h>
#include <stdio.h>
+#include <linux/list.h>
+#include "xyarray.h"
+
+struct thread_pid {
+ struct list_head next;
+ pid_t pid;
+};

struct thread_map {
int nr;
- pid_t map[];
+ struct list_head head;
};

+struct thread_map *thread_map__init(void);
struct thread_map *thread_map__new_by_pid(pid_t pid);
struct thread_map *thread_map__new_by_tid(pid_t tid);
struct thread_map *thread_map__new_by_uid(uid_t uid);
struct thread_map *thread_map__new(pid_t pid, pid_t tid, uid_t uid);
+struct thread_map *thread_map__empty_thread_map(void);

struct thread_map *thread_map__new_str(const char *pid,
const char *tid, uid_t uid);

+int thread_map__append(struct thread_map *threads, pid_t pid);
+int thread_map__remove(struct thread_map *threads, int idx);
+int thread_map__get_pid(struct thread_map *threads, int index);
+int thread_map__get_idx_by_pid(struct thread_map *threads, pid_t pid);
+
void thread_map__delete(struct thread_map *threads);

size_t thread_map__fprintf(struct thread_map *threads, FILE *fp);
diff --git a/tools/perf/util/xyarray.c b/tools/perf/util/xyarray.c
index fc48bda..5777bc2 100644
--- a/tools/perf/util/xyarray.c
+++ b/tools/perf/util/xyarray.c
@@ -78,13 +78,13 @@ int xyarray__remove(struct xyarray *xy, int y)
void xyarray__delete(struct xyarray *xy)
{
unsigned int i;
- struct xyentry *entry;
+ struct xyentry *entry, *tmp;

if (!xy)
return;

for (i = 0; i < xy->row_count; i++)
- list_for_each_entry(entry, &xy->rows[i].head, next) {
+ list_for_each_entry_safe(entry, tmp, &xy->rows[i].head, next) {
list_del(&entry->next);
free(entry);
}
--
1.7.9.5

--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/