path: root/src/odin.h

/*
   This file is part of odin, a memory profiler with fragmentation analysis.

   Copyright (C) 2007 Chris Wilson <chris@chris-wilson.co.uk>

   odin is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 3 of the
   License, or (at your option) any later version.

   odin is distributed in the hope that 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.

   You should have received a copy of the GNU General Public License
   along with odin. If not, see <http://www.gnu.org/licenses/>/

   The GNU General Public License is contained in the file COPYING.
*/

#ifndef ODIN_H
#define ODIN_H

#include <gtk/gtk.h>

G_BEGIN_DECLS

#define NUM_CALLERS 12

typedef struct _app App;
typedef struct _client Client;
typedef struct _allocator Allocator;
typedef struct _allocator_time AllocatorTime;
typedef struct _block Block;
typedef struct _chunk Chunk;
typedef struct _thread_faults ThreadFaults;

typedef struct _frame Frame;
typedef struct _frames Frames;

typedef struct _shared_object SharedObject;
typedef struct _shared_objects SharedObjects;

typedef struct _allocators Allocators;
typedef struct _block_map BlockMap;
typedef struct _call_graph CallGraph;
typedef struct _procmap Procmap;
typedef struct _summary Summary;
typedef struct _timeline Timeline;
typedef struct _spacetime Spacetime;

typedef struct _call_graph_frame CallGraphFrame;
typedef struct _call_graph_store CallGraphStore;
typedef struct _call_graph_store_class CallGraphStoreClass;


struct _block {
    Block *next, *ht_next;
    Block *prev, *ht_prev;
    gulong addr;
    gsize size;
    guint age;
    Allocator *allocator;
};

struct _chunk {
    struct _chunk *next;
    guint used, size;
    gchar mem[0];
};

struct _thread_faults {
    guint tid;
    guint fault_cnt;
    guint n_faults;
    ThreadFaults *next;
};

struct _allocator {
    gulong key;
    Allocator *next, *ht_next;
    guint n_frames;
    Frame **frames;
    const gchar *alloc_fn;
    guint alloc_fn_serial;
    guint64 max_bytes;
    struct _allocator_time {
	guint time;
	guint64 bytes;
	guint64 freed;
	gsize max_size;
	guint size_allocs[32];
	guint max_size_alloc;
	guint n_allocs;
	guint n_reallocs;
	guint n_frees;
	guint n_realloced_blocks;
	guint peak_blocks;
	gsize peak_bytes;
	ThreadFaults faults;
	AllocatorTime *next, *prev;
    } time[1];
    AllocatorTime *time_tail;
};

typedef enum {
    ALLOC,
    REALLOC,
    DEALLOC
} EventType;

typedef struct _event_base {
    EventType type;
    guint time;
    guint tid;
    Allocator *allocator;
} EventBase;

typedef struct _event_alloc {
    EventType type;
    guint time;
    guint tid;
    Allocator *allocator;

    gulong addr;
    gsize size;
} EventAlloc;

typedef struct _event_realloc {
    EventType type;
    guint time;
    guint tid;
    Allocator *allocator;

    gulong old_addr;
    gsize old_size;
    gulong new_addr;
    gsize new_size;
} EventRealloc;

typedef struct _event_dealloc {
    EventType type;
    guint time;
    guint tid;
    Allocator *allocator;

    gulong addr;
    gsize size;
} EventDealloc;

typedef union _event {
    EventType type;
    EventBase base;
    EventAlloc alloc;
    EventRealloc realloc;
    EventDealloc dealloc;
} Event;


App *
app_get (GtkWidget *widget);

void
app_set_busy (App *app, gboolean busy);

gboolean
app_add_alloc_fn (App *app, const gchar *pattern, GError **error);

gboolean
app_is_alloc_fn (App *app, Frame *f);

guint
app_get_alloc_fns_serial (App *app);

const gchar *
app_get_main_function (App *app);

guint
app_get_number_of_frames (App *app);

guint
app_get_number_of_allocators (App *app);

guint
app_get_number_of_blocks (App *app);

GtkWidget *
block_map_new (void);

void
block_map_set_highlight (BlockMap *block_map, GSList *blocks);

GtkWidget *
timeline_new (void);

void
timeline_reset (Timeline *tl);

void
timeline_add_datum (Timeline *tl, Client *client, guint time, Allocator *A);

GtkWidget *
spacetime_new (void);

void
spacetime_reset (Spacetime *st);

void
spacetime_add_datum (Spacetime *st, Client *client, guint time, Allocator *A);

GtkWidget *
allocators_new (void);

void
allocators_reset (Allocators *allocators);

GSList *
allocators_get_blocks_for_iter (Allocators *self,
	                        GtkTreeIter *iter,
				GSList *blocks);

void
allocators_select_blocks (Allocators *self, GSList *blocks);

gboolean
allocators_add_alloc_fn (Allocators *self,
	                 const gchar *pattern,
			 GError **error);

GtkWidget *
call_graph_new (void);

void
call_graph_update_view (CallGraph *self);

GtkWidget *
call_graph_tree_map_new (void);

GtkWidget *
call_graph_ring_new (void);

GtkWidget *
procmap_new (void);

G_CONST_RETURN Event *
app_find_prev_event_for_addr_range (App *app, guint time, gulong min, gulong max);

GtkWidget *
summary_new (gboolean total);

void
summary_update (Summary *summary, Client *client);

void
pretty_print_number (const char *number, gint len, char *output);

void
cell_layout_pretty_print_uint (GtkCellLayout   *layout,
	                       GtkCellRenderer *cell,
			       GtkTreeModel    *model,
			       GtkTreeIter     *iter,
			       gpointer         data);

void
cell_layout_pretty_print_uint64 (GtkCellLayout   *layout,
	                         GtkCellRenderer *cell,
				 GtkTreeModel    *model,
				 GtkTreeIter     *iter,
				 gpointer         data);

void
hsv_to_rgb (gdouble h, gdouble s, gdouble v, gdouble *rgb);

gdouble
median_double (gdouble *v, guint n);

G_END_DECLS

#endif /* ODIN_H */