Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 451db126 authored by Chris Phlipot's avatar Chris Phlipot Committed by Arnaldo Carvalho de Melo
Browse files

perf tools: Refactor code to move call path handling out of thread-stack 



Move the call path handling code out of thread-stack.c and
thread-stack.h to allow other components that are not part of
thread-stack to create call paths.

Summary:

- Create call-path.c and call-path.h and add them to the build.

- Move all call path related code out of thread-stack.c and thread-stack.h
  and into call-path.c and call-path.h.

- A small subset of structures and functions are now visible through
  call-path.h, which is required for thread-stack.c to continue to
  compile.

This change is a prerequisite for subsequent patches in this change set
and by itself contains no user-visible changes.

Signed-off-by: default avatarChris Phlipot <cphlipot0@gmail.com>
Acked-by: default avatarAdrian Hunter <adrian.hunter@intel.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/1461831551-12213-3-git-send-email-cphlipot0@gmail.com


Signed-off-by: default avatarArnaldo Carvalho de Melo <acme@redhat.com>
parent 9919a65e

tools/perf/util/Build

+1 −0
Original line number Diff line number Diff line
@@ -74,6 +74,7 @@ libperf-y += srcline.o 
libperf-y += data.o

libperf-y += tsc.o

libperf-y += cloexec.o

libperf-y += call-path.o

libperf-y += thread-stack.o

libperf-$(CONFIG_AUXTRACE) += auxtrace.o

libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/

tools/perf/util/call-path.c

0 → 100644
+122 −0
Original line number Diff line number Diff line 
/*

 * call-path.h: Manipulate a tree data structure containing function call paths

 * Copyright (c) 2014, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 */



#include <linux/rbtree.h>

#include <linux/list.h>



#include "util.h"

#include "call-path.h"



static void call_path__init(struct call_path *cp, struct call_path *parent,

			    struct symbol *sym, u64 ip, bool in_kernel)

{

	cp->parent = parent;

	cp->sym = sym;

	cp->ip = sym ? 0 : ip;

	cp->db_id = 0;

	cp->in_kernel = in_kernel;

	RB_CLEAR_NODE(&cp->rb_node);

	cp->children = RB_ROOT;

}



struct call_path_root *call_path_root__new(void)

{

	struct call_path_root *cpr;



	cpr = zalloc(sizeof(struct call_path_root));

	if (!cpr)

		return NULL;

	call_path__init(&cpr->call_path, NULL, NULL, 0, false);

	INIT_LIST_HEAD(&cpr->blocks);

	return cpr;

}



void call_path_root__free(struct call_path_root *cpr)

{

	struct call_path_block *pos, *n;



	list_for_each_entry_safe(pos, n, &cpr->blocks, node) {

		list_del(&pos->node);

		free(pos);

	}

	free(cpr);

}



static struct call_path *call_path__new(struct call_path_root *cpr,

					struct call_path *parent,

					struct symbol *sym, u64 ip,

					bool in_kernel)

{

	struct call_path_block *cpb;

	struct call_path *cp;

	size_t n;



	if (cpr->next < cpr->sz) {

		cpb = list_last_entry(&cpr->blocks, struct call_path_block,

				      node);

	} else {

		cpb = zalloc(sizeof(struct call_path_block));

		if (!cpb)

			return NULL;

		list_add_tail(&cpb->node, &cpr->blocks);

		cpr->sz += CALL_PATH_BLOCK_SIZE;

	}



	n = cpr->next++ & CALL_PATH_BLOCK_MASK;

	cp = &cpb->cp[n];



	call_path__init(cp, parent, sym, ip, in_kernel);



	return cp;

}



struct call_path *call_path__findnew(struct call_path_root *cpr,

				     struct call_path *parent,

				     struct symbol *sym, u64 ip, u64 ks)

{

	struct rb_node **p;

	struct rb_node *node_parent = NULL;

	struct call_path *cp;

	bool in_kernel = ip >= ks;



	if (sym)

		ip = 0;



	if (!parent)

		return call_path__new(cpr, parent, sym, ip, in_kernel);



	p = &parent->children.rb_node;

	while (*p != NULL) {

		node_parent = *p;

		cp = rb_entry(node_parent, struct call_path, rb_node);



		if (cp->sym == sym && cp->ip == ip)

			return cp;



		if (sym < cp->sym || (sym == cp->sym && ip < cp->ip))

			p = &(*p)->rb_left;

		else

			p = &(*p)->rb_right;

	}



	cp = call_path__new(cpr, parent, sym, ip, in_kernel);

	if (!cp)

		return NULL;



	rb_link_node(&cp->rb_node, node_parent, p);

	rb_insert_color(&cp->rb_node, &parent->children);



	return cp;

}

tools/perf/util/call-path.h

0 → 100644
+77 −0
Original line number Diff line number Diff line 
/*

 * call-path.h: Manipulate a tree data structure containing function call paths

 * Copyright (c) 2014, Intel Corporation.

 *

 * This program is free software; you can redistribute it and/or modify it

 * under the terms and conditions of the GNU General Public License,

 * version 2, as published by the Free Software Foundation.

 *

 * This program is distributed in the hope it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for

 * more details.

 *

 */



#ifndef __PERF_CALL_PATH_H

#define __PERF_CALL_PATH_H



#include <sys/types.h>



#include <linux/types.h>

#include <linux/rbtree.h>



/**

 * struct call_path - node in list of calls leading to a function call.

 * @parent: call path to the parent function call

 * @sym: symbol of function called

 * @ip: only if sym is null, the ip of the function

 * @db_id: id used for db-export

 * @in_kernel: whether function is a in the kernel

 * @rb_node: node in parent's tree of called functions

 * @children: tree of call paths of functions called

 *

 * In combination with the call_return structure, the call_path structure

 * defines a context-sensitve call-graph.

 */

struct call_path {

	struct call_path *parent;

	struct symbol *sym;

	u64 ip;

	u64 db_id;

	bool in_kernel;

	struct rb_node rb_node;

	struct rb_root children;

};



#define CALL_PATH_BLOCK_SHIFT 8

#define CALL_PATH_BLOCK_SIZE (1 << CALL_PATH_BLOCK_SHIFT)

#define CALL_PATH_BLOCK_MASK (CALL_PATH_BLOCK_SIZE - 1)



struct call_path_block {

	struct call_path cp[CALL_PATH_BLOCK_SIZE];

	struct list_head node;

};



/**

 * struct call_path_root - root of all call paths.

 * @call_path: root call path

 * @blocks: list of blocks to store call paths

 * @next: next free space

 * @sz: number of spaces

 */

struct call_path_root {

	struct call_path call_path;

	struct list_head blocks;

	size_t next;

	size_t sz;

};



struct call_path_root *call_path_root__new(void);

void call_path_root__free(struct call_path_root *cpr);



struct call_path *call_path__findnew(struct call_path_root *cpr,

				     struct call_path *parent,

				     struct symbol *sym, u64 ip, u64 ks);



#endif

tools/perf/util/db-export.c

+1 −0
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include "event.h"

#include "util.h"

#include "thread-stack.h"

#include "call-path.h"

#include "db-export.h"



struct deferred_export {

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

+1 −0
Original line number Diff line number Diff line
@@ -41,6 +41,7 @@ 
#include "../thread-stack.h"

#include "../trace-event.h"

#include "../machine.h"

#include "../call-path.h"

#include "thread_map.h"

#include "cpumap.h"

#include "stat.h"