perf tools: Add new COMM infrastructure

This new COMM infrastructure provides two features:

1) It keeps track of all comms lifecycle for a given thread. This way we
can associate a timeframe to any thread COMM, as long as
PERF_SAMPLE_TIME samples are joined to COMM and fork events.

As a result we should have more precise COMM sorted hists with seperated
entries for pre and post exec time after a fork.

2) It also makes sure that a given COMM string is not duplicated but
rather shared among the threads that refer to it. This way the threads
COMM can be compared against pointer values from the sort
infrastructure.

Signed-off-by: Frederic Weisbecker <fweisbec@gmail.com>
Tested-by: Jiri Olsa <jolsa@redhat.com>
Cc: Jiri Olsa <jolsa@redhat.com>
Cc: David Ahern <dsahern@gmail.com>
Cc: Ingo Molnar <mingo@elte.hu>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Stephane Eranian <eranian@google.com>
Link: http://lkml.kernel.org/n/tip-hwjf70b2wve9m2kosxiq8bb3@git.kernel.org
[ Rename some accessor functions ]
Signed-off-by: Namhyung Kim <namhyung@kernel.org>
[ Use __ as separator for class__method for private comm_str methods ]
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

1 files changed, 106 insertions, 0 deletions

diff --git a/tools/perf/util/comm.c b/tools/perf/util/comm.c
new file mode 100644
index 000000000000..8b3ac9f0207f
--- /dev/null
+++ b/tools/perf/util/comm.c
@@ -0,0 +1,106 @@
+#include "comm.h"
+#include "util.h"
+#include <stdlib.h>
+#include <stdio.h>
+
+struct comm_str {
+        char *str;
+        struct rb_node rb_node;
+        int ref;
+};
+
+/* Should perhaps be moved to struct machine */
+static struct rb_root comm_str_root;
+
+static void comm_str__get(struct comm_str *cs)
+{
+        cs->ref++;
+}
+
+static void comm_str__put(struct comm_str *cs)
+{
+        if (!--cs->ref) {
+                rb_erase(&cs->rb_node, &comm_str_root);
+                free(cs->str);
+                free(cs);
+        }
+}
+
+static struct comm_str *comm_str__alloc(const char *str)
+{
+        struct comm_str *cs;
+
+        cs = zalloc(sizeof(*cs));
+        if (!cs)
+                return NULL;
+
+        cs->str = strdup(str);
+        if (!cs->str) {
+                free(cs);
+                return NULL;
+        }
+
+        return cs;
+}
+
+static struct comm_str *comm_str__findnew(const char *str, struct rb_root *root)
+{
+        struct rb_node **p = &root->rb_node;
+        struct rb_node *parent = NULL;
+        struct comm_str *iter, *new;
+        int cmp;
+
+        while (*p != NULL) {
+                parent = *p;
+                iter = rb_entry(parent, struct comm_str, rb_node);
+
+                cmp = strcmp(str, iter->str);
+                if (!cmp)
+                        return iter;
+
+                if (cmp < 0)
+                        p = &(*p)->rb_left;
+                else
+                        p = &(*p)->rb_right;
+        }
+
+        new = comm_str__alloc(str);
+        if (!new)
+                return NULL;
+
+        rb_link_node(&new->rb_node, parent, p);
+        rb_insert_color(&new->rb_node, root);
+
+        return new;
+}
+
+struct comm *comm__new(const char *str, u64 timestamp)
+{
+        struct comm *comm = zalloc(sizeof(*comm));
+
+        if (!comm)
+                return NULL;
+
+        comm->start = timestamp;
+
+        comm->comm_str = comm_str__findnew(str, &comm_str_root);
+        if (!comm->comm_str) {
+                free(comm);
+                return NULL;
+        }
+
+        comm_str__get(comm->comm_str);
+
+        return comm;
+}
+
+void comm__free(struct comm *comm)
+{
+        comm_str__put(comm->comm_str);
+        free(comm);
+}
+
+const char *comm__str(const struct comm *comm)
+{
+        return comm->comm_str->str;
+}