varun-r-mallya/sysprof
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/sysprof.git synced 2025-12-31 20:36:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

build: rename all symbols to use sysprof_ as prefix

Browse Source 
As we gain in usage, we need to be more careful about using a prefix
that will not collide with other symbols. So version 3 of our ABI will
change to using Sysprof/SYSPROF/sysprof as the various prefixes.

The soname/api version bump will happen later on this branch so that
things are easier to test up until then.
This commit is contained in:
Christian Hergert
2019-05-08 12:03:46 -07:00
parent 4821883bfa
commit 53c718b708
143 changed files with 5792 additions and 5789 deletions
Download Patch File Download Diff File Expand all files Collapse all files

114
src/tools/sysprof-cat.c
View File

@ -105,7 +105,7 @@ gint
main (gint argc,
gchar *argv[])
{
g_autoptr(SpCaptureWriter) writer = NULL;
g_autoptr(SysprofCaptureWriter) writer = NULL;
g_autofree gchar *contents = NULL;
g_autofree gchar *tmpname = NULL;
gint64 first_start_time = G_MAXINT64;
@ -137,13 +137,13 @@ main (gint argc,
return EXIT_FAILURE;
}
writer = sp_capture_writer_new_from_fd (fd, 4096*4);
writer = sysprof_capture_writer_new_from_fd (fd, 4096*4);
for (guint i = 1; i < argc; i++)
{
g_autoptr(GError) error = NULL;
g_autoptr(SpCaptureReader) reader = sp_capture_reader_new (argv[i], &error);
SpCaptureFrameType type;
g_autoptr(SysprofCaptureReader) reader = sysprof_capture_reader_new (argv[i], &error);
SysprofCaptureFrameType type;
gint64 start_time;
if (reader == NULL)
@ -156,16 +156,16 @@ main (gint argc,
translate_table_clear (TRANSLATE_CTR);
translate_table_clear (TRANSLATE_ADDR);
start_time = sp_capture_reader_get_start_time (reader);
start_time = sysprof_capture_reader_get_start_time (reader);
if (start_time < first_start_time)
first_start_time = start_time;
while (sp_capture_reader_peek_type (reader, &type))
while (sysprof_capture_reader_peek_type (reader, &type))
{
SpCaptureFrame fr;
SysprofCaptureFrame fr;
if (sp_capture_reader_peek_frame (reader, &fr))
if (sysprof_capture_reader_peek_frame (reader, &fr))
{
if (fr.time > end_time)
end_time = fr.time;
@ -173,28 +173,28 @@ main (gint argc,
switch (type)
{
case SP_CAPTURE_FRAME_TIMESTAMP:
case SYSPROF_CAPTURE_FRAME_TIMESTAMP:
{
const SpCaptureTimestamp *frame;
const SysprofCaptureTimestamp *frame;
if (!(frame = sp_capture_reader_read_timestamp (reader)))
if (!(frame = sysprof_capture_reader_read_timestamp (reader)))
goto panic;
sp_capture_writer_add_timestamp (writer,
sysprof_capture_writer_add_timestamp (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid);
break;
}
case SP_CAPTURE_FRAME_MAP:
case SYSPROF_CAPTURE_FRAME_MAP:
{
const SpCaptureMap *frame;
const SysprofCaptureMap *frame;
if (!(frame = sp_capture_reader_read_map (reader)))
if (!(frame = sysprof_capture_reader_read_map (reader)))
goto panic;
sp_capture_writer_add_map (writer,
sysprof_capture_writer_add_map (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -206,14 +206,14 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_MARK:
case SYSPROF_CAPTURE_FRAME_MARK:
{
const SpCaptureMark *frame;
const SysprofCaptureMark *frame;
if (!(frame = sp_capture_reader_read_mark (reader)))
if (!(frame = sysprof_capture_reader_read_mark (reader)))
goto panic;
sp_capture_writer_add_mark (writer,
sysprof_capture_writer_add_mark (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -228,14 +228,14 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_PROCESS:
case SYSPROF_CAPTURE_FRAME_PROCESS:
{
const SpCaptureProcess *frame;
const SysprofCaptureProcess *frame;
if (!(frame = sp_capture_reader_read_process (reader)))
if (!(frame = sysprof_capture_reader_read_process (reader)))
goto panic;
sp_capture_writer_add_process (writer,
sysprof_capture_writer_add_process (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -243,14 +243,14 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_FORK:
case SYSPROF_CAPTURE_FRAME_FORK:
{
const SpCaptureFork *frame;
const SysprofCaptureFork *frame;
if (!(frame = sp_capture_reader_read_fork (reader)))
if (!(frame = sysprof_capture_reader_read_fork (reader)))
goto panic;
sp_capture_writer_add_fork (writer,
sysprof_capture_writer_add_fork (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -258,34 +258,34 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_EXIT:
case SYSPROF_CAPTURE_FRAME_EXIT:
{
const SpCaptureExit *frame;
const SysprofCaptureExit *frame;
if (!(frame = sp_capture_reader_read_exit (reader)))
if (!(frame = sysprof_capture_reader_read_exit (reader)))
goto panic;
sp_capture_writer_add_exit (writer,
sysprof_capture_writer_add_exit (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid);
break;
}
case SP_CAPTURE_FRAME_JITMAP:
case SYSPROF_CAPTURE_FRAME_JITMAP:
{
GHashTable *jitmap;
GHashTableIter iter;
const gchar *name;
guint64 addr;
if (!(jitmap = sp_capture_reader_read_jitmap (reader)))
if (!(jitmap = sysprof_capture_reader_read_jitmap (reader)))
goto panic;
g_hash_table_iter_init (&iter, jitmap);
while (g_hash_table_iter_next (&iter, (gpointer *)&addr, (gpointer *)&name))
{
guint64 replace = sp_capture_writer_add_jitmap (writer, name);
guint64 replace = sysprof_capture_writer_add_jitmap (writer, name);
/* We need to keep a table of replacement addresses so that
* we can translate the samples into the destination address
* space that we synthesized for the address identifier.
@ -300,20 +300,20 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_SAMPLE:
case SYSPROF_CAPTURE_FRAME_SAMPLE:
{
const SpCaptureSample *frame;
const SysprofCaptureSample *frame;
if (!(frame = sp_capture_reader_read_sample (reader)))
if (!(frame = sysprof_capture_reader_read_sample (reader)))
goto panic;
{
SpCaptureAddress addrs[frame->n_addrs];
SysprofCaptureAddress addrs[frame->n_addrs];
for (guint z = 0; z < frame->n_addrs; z++)
addrs[z] = translate_table_translate (TRANSLATE_ADDR, frame->addrs[z]);
sp_capture_writer_add_sample (writer,
sysprof_capture_writer_add_sample (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -325,22 +325,22 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_CTRDEF:
case SYSPROF_CAPTURE_FRAME_CTRDEF:
{
const SpCaptureFrameCounterDefine *frame;
const SysprofCaptureFrameCounterDefine *frame;
if (!(frame = sp_capture_reader_read_counter_define (reader)))
if (!(frame = sysprof_capture_reader_read_counter_define (reader)))
goto panic;
{
g_autoptr(GArray) counter = g_array_new (FALSE, FALSE, sizeof (SpCaptureCounter));
g_autoptr(GArray) counter = g_array_new (FALSE, FALSE, sizeof (SysprofCaptureCounter));
for (guint z = 0; z < frame->n_counters; z++)
{
SpCaptureCounter c = frame->counters[z];
SysprofCaptureCounter c = frame->counters[z];
guint src = c.id;
c.id = sp_capture_writer_request_counter (writer, 1);
c.id = sysprof_capture_writer_request_counter (writer, 1);
if (c.id != src)
translate_table_add (TRANSLATE_CTR, src, c.id);
@ -348,7 +348,7 @@ main (gint argc,
g_array_append_val (counter, c);
}
sp_capture_writer_define_counters (writer,
sysprof_capture_writer_define_counters (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
@ -361,27 +361,27 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_CTRSET:
case SYSPROF_CAPTURE_FRAME_CTRSET:
{
const SpCaptureFrameCounterSet *frame;
const SysprofCaptureFrameCounterSet *frame;
if (!(frame = sp_capture_reader_read_counter_set (reader)))
if (!(frame = sysprof_capture_reader_read_counter_set (reader)))
goto panic;
{
g_autoptr(GArray) ids = g_array_new (FALSE, FALSE, sizeof (guint));
g_autoptr(GArray) values = g_array_new (FALSE, FALSE, sizeof (SpCaptureCounterValue));
g_autoptr(GArray) values = g_array_new (FALSE, FALSE, sizeof (SysprofCaptureCounterValue));
for (guint z = 0; z < frame->n_values; z++)
{
const SpCaptureCounterValues *v = &frame->values[z];
const SysprofCaptureCounterValues *v = &frame->values[z];
for (guint y = 0; y < G_N_ELEMENTS (v->ids); y++)
{
if (v->ids[y])
{
guint dst = translate_table_translate (TRANSLATE_CTR, v->ids[y]);
SpCaptureCounterValue value = v->values[y];
SysprofCaptureCounterValue value = v->values[y];
g_array_append_val (ids, dst);
g_array_append_val (values, value);
@ -391,12 +391,12 @@ main (gint argc,
g_assert (ids->len == values->len);
sp_capture_writer_set_counters (writer,
sysprof_capture_writer_set_counters (writer,
frame->frame.time,
frame->frame.cpu,
frame->frame.pid,
(const guint *)(gpointer)ids->data,
(const SpCaptureCounterValue *)(gpointer)values->data,
(const SysprofCaptureCounterValue *)(gpointer)values->data,
ids->len);
}
@ -409,10 +409,10 @@ main (gint argc,
}
}
sp_capture_writer_flush (writer);
sysprof_capture_writer_flush (writer);
/* do this after flushing as it uses pwrite() to replace data */
_sp_capture_writer_set_time_range (writer, first_start_time, end_time);
_sysprof_capture_writer_set_time_range (writer, first_start_time, end_time);
if (g_file_get_contents (tmpname, &contents, &len, NULL))
write (STDOUT_FILENO, contents, len);

46
src/tools/sysprof-cli.c
View File

@ -31,7 +31,7 @@
#include <sysprof.h>
static GMainLoop *main_loop;
static SpProfiler *profiler;
static SysprofProfiler *profiler;
static int efd = -1;
static int exit_code = EXIT_SUCCESS;
@ -48,7 +48,7 @@ dispatch (GSource *source,
GSourceFunc callback,
gpointer callback_data)
{
sp_profiler_stop (profiler);
sysprof_profiler_stop (profiler);
g_main_loop_quit (main_loop);
return G_SOURCE_REMOVE;
}
@ -58,18 +58,18 @@ static GSourceFuncs source_funcs = {
};
static void
profiler_stopped (SpProfiler *profiler_,
profiler_stopped (SysprofProfiler *profiler_,
GMainLoop *main_loop_)
{
g_main_loop_quit (main_loop_);
}
static void
profiler_failed (SpProfiler *profiler_,
profiler_failed (SysprofProfiler *profiler_,
const GError *reason,
GMainLoop *main_loop_)
{
g_assert (SP_IS_PROFILER (profiler_));
g_assert (SYSPROF_IS_PROFILER (profiler_));
g_assert (reason != NULL);
g_printerr ("Failure: %s\n", reason->message);
@ -80,8 +80,8 @@ gint
main (gint argc,
gchar *argv[])
{
SpCaptureWriter *writer;
SpSource *source;
SysprofCaptureWriter *writer;
SysprofSource *source;
GMainContext *main_context;
GOptionContext *context;
const gchar *filename = "capture.syscap";
@ -105,7 +105,7 @@ main (gint argc,
{ NULL }
};
sp_clock_init ();
sysprof_clock_init ();
context = g_option_context_new (_("[CAPTURE_FILE] — Sysprof"));
g_option_context_add_main_entries (context, entries, GETTEXT_PACKAGE);
@ -143,7 +143,7 @@ main (gint argc,
g_source_add_unix_fd (gsource, efd, G_IO_IN);
g_source_attach (gsource, NULL);
profiler = sp_local_profiler_new ();
profiler = sysprof_local_profiler_new ();
g_signal_connect (profiler,
"failed",
@ -202,41 +202,41 @@ main (gint argc,
}
}
writer = sp_capture_writer_new_from_fd (fd, 0);
sp_profiler_set_writer (profiler, writer);
writer = sysprof_capture_writer_new_from_fd (fd, 0);
sysprof_profiler_set_writer (profiler, writer);
source = sp_proc_source_new ();
sp_profiler_add_source (profiler, source);
source = sysprof_proc_source_new ();
sysprof_profiler_add_source (profiler, source);
g_object_unref (source);
source = sp_perf_source_new ();
sp_profiler_add_source (profiler, source);
source = sysprof_perf_source_new ();
sysprof_profiler_add_source (profiler, source);
g_object_unref (source);
if (!no_cpu)
{
source = sp_hostinfo_source_new ();
sp_profiler_add_source (profiler, source);
source = sysprof_hostinfo_source_new ();
sysprof_profiler_add_source (profiler, source);
g_object_unref (source);
}
if (!no_memory)
{
source = sp_memory_source_new ();
sp_profiler_add_source (profiler, source);
source = sysprof_memory_source_new ();
sysprof_profiler_add_source (profiler, source);
g_object_unref (source);
}
if (pid != -1)
{
sp_profiler_set_whole_system (profiler, FALSE);
sp_profiler_add_pid (profiler, pid);
sysprof_profiler_set_whole_system (profiler, FALSE);
sysprof_profiler_add_pid (profiler, pid);
}
signal (SIGINT, signal_handler);
signal (SIGTERM, signal_handler);
sp_profiler_start (profiler);
sysprof_profiler_start (profiler);
/* Restore the process if we stopped it */
if (command)
@ -252,7 +252,7 @@ main (gint argc,
close (efd);
g_clear_pointer (&writer, sp_capture_writer_unref);
g_clear_pointer (&writer, sysprof_capture_writer_unref);
g_clear_object (&profiler);
g_clear_pointer (&main_loop, g_main_loop_unref);
g_clear_pointer (&context, g_option_context_free);

70
src/tools/sysprof-dump.c
View File

@ -28,8 +28,8 @@ gint
main (gint argc,
gchar *argv[])
{
SpCaptureReader *reader;
SpCaptureFrameType type;
SysprofCaptureReader *reader;
SysprofCaptureFrameType type;
GHashTable *ctrtypes;
GError *error = NULL;
gint64 begin_time;
@ -41,10 +41,10 @@ main (gint argc,
return EXIT_FAILURE;
}
reader = sp_capture_reader_new (argv[1], &error);
reader = sysprof_capture_reader_new (argv[1], &error);
ctrtypes = g_hash_table_new (NULL, NULL);
begin_time = sp_capture_reader_get_start_time (reader);
begin_time = sysprof_capture_reader_get_start_time (reader);
#define SET_CTR_TYPE(i,t) g_hash_table_insert(ctrtypes, GINT_TO_POINTER(i), GINT_TO_POINTER(t))
#define GET_CTR_TYPE(i) GPOINTER_TO_INT(g_hash_table_lookup(ctrtypes, GINT_TO_POINTER(i)))
@ -55,19 +55,19 @@ main (gint argc,
return EXIT_FAILURE;
}
begin_time = sp_capture_reader_get_start_time (reader);
end_time = sp_capture_reader_get_end_time (reader);
begin_time = sysprof_capture_reader_get_start_time (reader);
end_time = sysprof_capture_reader_get_end_time (reader);
g_print ("Capture Time Range: %"G_GUINT64_FORMAT" to %"G_GUINT64_FORMAT" (%lf)\n",
begin_time, end_time, (end_time - begin_time) / (gdouble)NSEC_PER_SEC);
while (sp_capture_reader_peek_type (reader, &type))
while (sysprof_capture_reader_peek_type (reader, &type))
{
switch (type)
{
case SP_CAPTURE_FRAME_EXIT:
case SYSPROF_CAPTURE_FRAME_EXIT:
{
const SpCaptureExit *ex = sp_capture_reader_read_exit (reader);
const SysprofCaptureExit *ex = sysprof_capture_reader_read_exit (reader);
if (ex == NULL)
return EXIT_FAILURE;
@ -77,9 +77,9 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_FORK:
case SYSPROF_CAPTURE_FRAME_FORK:
{
const SpCaptureFork *fk = sp_capture_reader_read_fork (reader);
const SysprofCaptureFork *fk = sysprof_capture_reader_read_fork (reader);
if (fk == NULL)
return EXIT_FAILURE;
@ -89,11 +89,11 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_JITMAP:
case SYSPROF_CAPTURE_FRAME_JITMAP:
{
g_autoptr(GHashTable) ret = sp_capture_reader_read_jitmap (reader);
g_autoptr(GHashTable) ret = sysprof_capture_reader_read_jitmap (reader);
GHashTableIter iter;
SpCaptureAddress addr;
SysprofCaptureAddress addr;
const gchar *str;
if (ret == NULL)
@ -103,14 +103,14 @@ main (gint argc,
g_hash_table_iter_init (&iter, ret);
while (g_hash_table_iter_next (&iter, (gpointer *)&addr, (gpointer *)&str))
g_print (" "SP_CAPTURE_ADDRESS_FORMAT" : %s\n", addr, str);
g_print (" "SYSPROF_CAPTURE_ADDRESS_FORMAT" : %s\n", addr, str);
break;
}
case SP_CAPTURE_FRAME_MAP:
case SYSPROF_CAPTURE_FRAME_MAP:
{
const SpCaptureMap *map = sp_capture_reader_read_map (reader);
const SysprofCaptureMap *map = sysprof_capture_reader_read_map (reader);
g_print ("MAP: pid=%d time=%"G_GINT64_FORMAT"\n"
" start = %"G_GUINT64_FORMAT"\n"
@ -124,9 +124,9 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_MARK:
case SYSPROF_CAPTURE_FRAME_MARK:
{
const SpCaptureMark *mark = sp_capture_reader_read_mark (reader);
const SysprofCaptureMark *mark = sysprof_capture_reader_read_mark (reader);
gdouble ptime = (mark->frame.time - begin_time) / (gdouble)NSEC_PER_SEC;
g_print ("MARK: pid=%d time=%"G_GINT64_FORMAT" (%lf)\n"
@ -140,9 +140,9 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_PROCESS:
case SYSPROF_CAPTURE_FRAME_PROCESS:
{
const SpCaptureProcess *pr = sp_capture_reader_read_process (reader);
const SysprofCaptureProcess *pr = sysprof_capture_reader_read_process (reader);
if (pr == NULL)
perror ("Failed to read process");
@ -152,37 +152,37 @@ main (gint argc,
break;
}
case SP_CAPTURE_FRAME_SAMPLE:
case SYSPROF_CAPTURE_FRAME_SAMPLE:
{
const SpCaptureSample *s = sp_capture_reader_read_sample (reader);
const SysprofCaptureSample *s = sysprof_capture_reader_read_sample (reader);
gdouble ptime = (s->frame.time - begin_time) / (gdouble)NSEC_PER_SEC;
guint i;
g_print ("SAMPLE: pid=%d time=%"G_GINT64_FORMAT" (%lf)\n", s->frame.pid, s->frame.time, ptime);
for (i = 0; i < s->n_addrs; i++)
g_print (" "SP_CAPTURE_ADDRESS_FORMAT"\n", s->addrs[i]);
g_print (" "SYSPROF_CAPTURE_ADDRESS_FORMAT"\n", s->addrs[i]);
break;
}
case SP_CAPTURE_FRAME_TIMESTAMP:
case SYSPROF_CAPTURE_FRAME_TIMESTAMP:
{
const SpCaptureTimestamp *ts = sp_capture_reader_read_timestamp (reader);
const SysprofCaptureTimestamp *ts = sysprof_capture_reader_read_timestamp (reader);
g_print ("TIMESTAMP: pid=%d time=%"G_GINT64_FORMAT"\n", ts->frame.pid, ts->frame.time);
break;
}
case SP_CAPTURE_FRAME_CTRDEF:
case SYSPROF_CAPTURE_FRAME_CTRDEF:
{
const SpCaptureFrameCounterDefine *def = sp_capture_reader_read_counter_define (reader);
const SysprofCaptureFrameCounterDefine *def = sysprof_capture_reader_read_counter_define (reader);
guint i;
g_print ("NEW COUNTERS: pid=%d time=%"G_GINT64_FORMAT"\n", def->frame.pid, def->frame.time);
for (i = 0; i < def->n_counters; i++)
{
const SpCaptureCounter *ctr = &def->counters[i];
const SysprofCaptureCounter *ctr = &def->counters[i];
SET_CTR_TYPE (ctr->id, ctr->type);
@ -195,27 +195,27 @@ main (gint argc,
}
break;
case SP_CAPTURE_FRAME_CTRSET:
case SYSPROF_CAPTURE_FRAME_CTRSET:
{
const SpCaptureFrameCounterSet *set = sp_capture_reader_read_counter_set (reader);
const SysprofCaptureFrameCounterSet *set = sysprof_capture_reader_read_counter_set (reader);
guint i;
g_print ("SET COUNTERS: pid=%d time=%"G_GINT64_FORMAT"\n", set->frame.pid, set->frame.time);
for (i = 0; i < set->n_values; i++)
{
const SpCaptureCounterValues *values = &set->values[i];
const SysprofCaptureCounterValues *values = &set->values[i];
guint j;
for (j = 0; j < G_N_ELEMENTS (values->ids); j++)
{
if (values->ids[j])
{
if (GET_CTR_TYPE (values->ids[j]) == SP_CAPTURE_COUNTER_INT64)
if (GET_CTR_TYPE (values->ids[j]) == SYSPROF_CAPTURE_COUNTER_INT64)
g_print (" COUNTER(%d): %"G_GINT64_FORMAT"\n",
values->ids[j],
values->values[j].v64);
else if (GET_CTR_TYPE (values->ids[j]) == SP_CAPTURE_COUNTER_DOUBLE)
else if (GET_CTR_TYPE (values->ids[j]) == SYSPROF_CAPTURE_COUNTER_DOUBLE)
g_print (" COUNTER(%d): %lf\n",
values->ids[j],
values->values[j].vdbl);
@ -227,7 +227,7 @@ main (gint argc,
default:
g_print ("Skipping unknown frame type: (%d): ", type);
if (!sp_capture_reader_skip (reader))
if (!sysprof_capture_reader_skip (reader))
{
g_print ("Failed\n");
return EXIT_FAILURE;