varun-r-mallya/sysprof
1
0
Fork 0
mirror of https://github.com/varun-r-mallya/sysprof.git synced 2026-02-10 07:00:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

capture-writer: use frame initializer function

Browse Source
This commit is contained in:
Vito Caputo
2016-11-20 16:59:20 -08:00
committed by Christian Hergert
parent 9d8085a73b
commit e97499b2a4
1 changed files with 118 additions and 145 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
lib/sp-capture-writer.c
View File

@ -101,6 +101,24 @@ G_DEFINE_BOXED_TYPE (SpCaptureWriter, sp_capture_writer,
sp_capture_writer_ref, sp_capture_writer_unref) sp_capture_writer_ref, sp_capture_writer_unref)
#endif #endif
static inline void
sp_capture_writer_frame_init (SpCaptureFrame *frame_,
gint len,
gint cpu,
GPid pid,
gint64 time_,
SpCaptureFrameType type)
{
g_assert (frame_ != NULL);
frame_->len = len;
frame_->cpu = cpu;
frame_->pid = pid;
frame_->time = time_;
frame_->type = type;
frame_->padding = 0;
}
static void static void
sp_capture_writer_finalize (SpCaptureWriter *self) sp_capture_writer_finalize (SpCaptureWriter *self)
{ {
@ -191,6 +209,30 @@ sp_capture_writer_ensure_space_for (SpCaptureWriter *self,
return TRUE; return TRUE;
} }
static inline gpointer
sp_capture_writer_allocate (SpCaptureWriter *self,
gsize *len)
{
gpointer p;
g_assert (self != NULL);
g_assert (len != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
sp_capture_writer_realign (len);
if (!sp_capture_writer_ensure_space_for (self, *len))
return NULL;
p = (gpointer)&self->buf[self->pos];
self->pos += *len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
return p;
}
static gboolean static gboolean
sp_capture_writer_flush_jitmap (SpCaptureWriter *self) sp_capture_writer_flush_jitmap (SpCaptureWriter *self)
{ {
@ -209,11 +251,12 @@ sp_capture_writer_flush_jitmap (SpCaptureWriter *self)
sp_capture_writer_realign (&len); sp_capture_writer_realign (&len);
jitmap.frame.len = len; sp_capture_writer_frame_init (&jitmap.frame,
jitmap.frame.cpu = -1; len,
jitmap.frame.pid = getpid (); -1,
jitmap.frame.time = SP_CAPTURE_CURRENT_TIME; getpid (),
jitmap.frame.type = SP_CAPTURE_FRAME_JITMAP; SP_CAPTURE_CURRENT_TIME,
SP_CAPTURE_FRAME_JITMAP);
jitmap.n_jitmaps = self->addr_hash_size; jitmap.n_jitmaps = self->addr_hash_size;
if (sizeof jitmap != write (self->fd, &jitmap, sizeof jitmap)) if (sizeof jitmap != write (self->fd, &jitmap, sizeof jitmap))
@ -368,6 +411,7 @@ sp_capture_writer_new_from_fd (int fd,
SpCaptureWriter *self; SpCaptureWriter *self;
SpCaptureFileHeader *header; SpCaptureFileHeader *header;
GTimeVal tv; GTimeVal tv;
gsize header_len = sizeof(*header);
if (buffer_size == 0) if (buffer_size == 0)
buffer_size = DEFAULT_BUFFER_SIZE; buffer_size = DEFAULT_BUFFER_SIZE;
@ -388,7 +432,10 @@ sp_capture_writer_new_from_fd (int fd,
g_get_current_time (&tv); g_get_current_time (&tv);
nowstr = g_time_val_to_iso8601 (&tv); nowstr = g_time_val_to_iso8601 (&tv);
header = (SpCaptureFileHeader *)(gpointer)self->buf; header = sp_capture_writer_allocate (self, &header_len);
if (!header)
return NULL;
header->magic = SP_CAPTURE_MAGIC; header->magic = SP_CAPTURE_MAGIC;
header->version = 1; header->version = 1;
#ifdef G_LITTLE_ENDIAN #ifdef G_LITTLE_ENDIAN
@ -402,8 +449,6 @@ sp_capture_writer_new_from_fd (int fd,
header->end_time = 0; header->end_time = 0;
memset (header->suffix, 0, sizeof header->suffix); memset (header->suffix, 0, sizeof header->suffix);
self->pos += sizeof *header;
if (!sp_capture_writer_flush_data (self)) if (!sp_capture_writer_flush_data (self))
{ {
sp_capture_writer_finalize (self); sp_capture_writer_finalize (self);
@ -460,25 +505,20 @@ sp_capture_writer_add_map (SpCaptureWriter *self,
filename = ""; filename = "";
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
g_assert (filename != NULL); g_assert (filename != NULL);
len = sizeof *ev + strlen (filename) + 1; len = sizeof *ev + strlen (filename) + 1;
sp_capture_writer_realign (&len); ev = (SpCaptureMap *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
ev = (SpCaptureMap *)(gpointer)&self->buf[self->pos]; cpu,
ev->frame.len = len; pid,
ev->frame.cpu = cpu; time,
ev->frame.pid = pid; SP_CAPTURE_FRAME_MAP);
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_MAP;
ev->frame.padding = 0;
ev->start = start; ev->start = start;
ev->end = end; ev->end = end;
ev->offset = offset; ev->offset = offset;
@ -487,10 +527,6 @@ sp_capture_writer_add_map (SpCaptureWriter *self,
g_strlcpy (ev->filename, filename, len - sizeof *ev); g_strlcpy (ev->filename, filename, len - sizeof *ev);
ev->filename[len - sizeof *ev - 1] = '\0'; ev->filename[len - sizeof *ev - 1] = '\0';
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_MAP]++; self->stat.frame_count[SP_CAPTURE_FRAME_MAP]++;
return TRUE; return TRUE;
@ -528,33 +564,24 @@ sp_capture_writer_add_process (SpCaptureWriter *self,
cmdline = ""; cmdline = "";
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
g_assert (cmdline != NULL); g_assert (cmdline != NULL);
len = sizeof *ev + strlen (cmdline) + 1; len = sizeof *ev + strlen (cmdline) + 1;
sp_capture_writer_realign (&len); ev = (SpCaptureProcess *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
ev = (SpCaptureProcess *)(gpointer)&self->buf[self->pos]; cpu,
ev->frame.len = len; pid,
ev->frame.cpu = cpu; time,
ev->frame.pid = pid; SP_CAPTURE_FRAME_PROCESS);
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_PROCESS;
ev->frame.padding = 0;
g_strlcpy (ev->cmdline, cmdline, len - sizeof *ev); g_strlcpy (ev->cmdline, cmdline, len - sizeof *ev);
ev->cmdline[len - sizeof *ev - 1] = '\0'; ev->cmdline[len - sizeof *ev - 1] = '\0';
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_PROCESS]++; self->stat.frame_count[SP_CAPTURE_FRAME_PROCESS]++;
return TRUE; return TRUE;
@ -572,32 +599,23 @@ sp_capture_writer_add_sample (SpCaptureWriter *self,
gsize len; gsize len;
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
len = sizeof *ev + (n_addrs * sizeof (SpCaptureAddress)); len = sizeof *ev + (n_addrs * sizeof (SpCaptureAddress));
sp_capture_writer_realign (&len); ev = (SpCaptureSample *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
ev = (SpCaptureSample *)(gpointer)&self->buf[self->pos]; cpu,
ev->frame.len = len; pid,
ev->frame.cpu = cpu; time,
ev->frame.pid = pid; SP_CAPTURE_FRAME_SAMPLE);
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_SAMPLE;
ev->frame.padding = 0;
ev->n_addrs = n_addrs; ev->n_addrs = n_addrs;
memcpy (ev->addrs, addrs, (n_addrs * sizeof (SpCaptureAddress))); memcpy (ev->addrs, addrs, (n_addrs * sizeof (SpCaptureAddress)));
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_SAMPLE]++; self->stat.frame_count[SP_CAPTURE_FRAME_SAMPLE]++;
return TRUE; return TRUE;
@ -614,28 +632,19 @@ sp_capture_writer_add_fork (SpCaptureWriter *self,
gsize len = sizeof *ev; gsize len = sizeof *ev;
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
sp_capture_writer_realign (&len); ev = (SpCaptureFork *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
ev = (SpCaptureFork *)(gpointer)&self->buf[self->pos]; cpu,
ev->frame.len = len; pid,
ev->frame.cpu = cpu; time,
ev->frame.pid = pid; SP_CAPTURE_FRAME_FORK);
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_FORK;
ev->frame.padding = 0;
ev->child_pid = child_pid; ev->child_pid = child_pid;
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_FORK]++; self->stat.frame_count[SP_CAPTURE_FRAME_FORK]++;
return TRUE; return TRUE;
@ -651,26 +660,17 @@ sp_capture_writer_add_exit (SpCaptureWriter *self,
gsize len = sizeof *ev; gsize len = sizeof *ev;
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
sp_capture_writer_realign (&len); ev = (SpCaptureExit *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
ev = (SpCaptureExit *)(gpointer)&self->buf[self->pos]; cpu,
ev->frame.len = len; pid,
ev->frame.cpu = cpu; time,
ev->frame.pid = pid; SP_CAPTURE_FRAME_EXIT);
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_EXIT;
ev->frame.padding = 0;
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_EXIT]++; self->stat.frame_count[SP_CAPTURE_FRAME_EXIT]++;
@ -687,28 +687,19 @@ sp_capture_writer_add_timestamp (SpCaptureWriter *self,
gsize len = sizeof *ev; gsize len = sizeof *ev;
g_assert (self != NULL); g_assert (self != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
sp_capture_writer_realign (&len); ev = (SpCaptureTimestamp *)sp_capture_writer_allocate (self, &len);
if (!ev)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&ev->frame,
len,
cpu,
pid,
time,
SP_CAPTURE_FRAME_TIMESTAMP);
ev = (SpCaptureTimestamp *)(gpointer)&self->buf[self->pos]; self->stat.frame_count[SP_CAPTURE_FRAME_TIMESTAMP]++;
ev->frame.len = len;
ev->frame.cpu = cpu;
ev->frame.pid = pid;
ev->frame.time = time;
ev->frame.type = SP_CAPTURE_FRAME_TIMESTAMP;
ev->frame.padding = 0;
self->pos += ev->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_TIMESTAMP]++;
return TRUE; return TRUE;
} }
@ -1020,37 +1011,28 @@ sp_capture_writer_define_counters (SpCaptureWriter *self,
g_assert (self != NULL); g_assert (self != NULL);
g_assert (counters != NULL); g_assert (counters != NULL);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
if (n_counters == 0) if (n_counters == 0)
return TRUE; return TRUE;
len = sizeof *def + (sizeof *counters * n_counters); len = sizeof *def + (sizeof *counters * n_counters);
sp_capture_writer_realign (&len); def = (SpCaptureFrameCounterDefine *)sp_capture_writer_allocate (self, &len);
if (!def)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&def->frame,
len,
def = (SpCaptureFrameCounterDefine *)&self->buf[self->pos]; cpu,
def->frame.len = len; pid,
def->frame.cpu = cpu; time,
def->frame.pid = pid; SP_CAPTURE_FRAME_CTRDEF);
def->frame.time = time;
def->frame.type = SP_CAPTURE_FRAME_CTRDEF;
def->frame.padding = 0;
def->padding = 0; def->padding = 0;
def->n_counters = n_counters; def->n_counters = n_counters;
for (i = 0; i < n_counters; i++) for (i = 0; i < n_counters; i++)
def->counters[i] = counters[i]; def->counters[i] = counters[i];
self->pos += def->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_CTRDEF]++; self->stat.frame_count[SP_CAPTURE_FRAME_CTRDEF]++;
return TRUE; return TRUE;
@ -1075,7 +1057,6 @@ sp_capture_writer_set_counters (SpCaptureWriter *self,
g_assert (self != NULL); g_assert (self != NULL);
g_assert (counters_ids != NULL); g_assert (counters_ids != NULL);
g_assert (values != NULL || !n_counters); g_assert (values != NULL || !n_counters);
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
if (n_counters == 0) if (n_counters == 0)
return TRUE; return TRUE;
@ -1087,20 +1068,16 @@ sp_capture_writer_set_counters (SpCaptureWriter *self,
len = sizeof *set + (n_groups * sizeof (SpCaptureCounterValues)); len = sizeof *set + (n_groups * sizeof (SpCaptureCounterValues));
sp_capture_writer_realign (&len); set = (SpCaptureFrameCounterSet *)sp_capture_writer_allocate (self, &len);
if (!set)
if (!sp_capture_writer_ensure_space_for (self, len))
return FALSE; return FALSE;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0); sp_capture_writer_frame_init (&set->frame,
len,
set = (SpCaptureFrameCounterSet *)&self->buf[self->pos]; cpu,
set->frame.len = len; pid,
set->frame.cpu = cpu; time,
set->frame.pid = pid; SP_CAPTURE_FRAME_CTRSET);
set->frame.time = time;
set->frame.type = SP_CAPTURE_FRAME_CTRSET;
set->frame.padding = 0;
set->padding = 0; set->padding = 0;
set->n_values = n_groups; set->n_values = n_groups;
@ -1118,10 +1095,6 @@ sp_capture_writer_set_counters (SpCaptureWriter *self,
} }
} }
self->pos += set->frame.len;
g_assert ((self->pos % SP_CAPTURE_ALIGN) == 0);
self->stat.frame_count[SP_CAPTURE_FRAME_CTRSET]++; self->stat.frame_count[SP_CAPTURE_FRAME_CTRSET]++;
return TRUE; return TRUE;