libpfms.c File Reference

Include dependency graph for libpfms.c:

Go to the source code of this file.

Data Structures
struct	barrier_t
struct	pfms_cpu_t
struct	pfms_thread_t
struct	pfms_session_t

Macros
#define	dprint(format, arg...)

Enumerations
enum	pfms_cmd_t {   CMD_NONE , CMD_CTX , CMD_LOAD , CMD_UNLOAD ,   CMD_WPMCS , CMD_WPMDS , CMD_RPMDS , CMD_STOP ,   CMD_START , CMD_CLOSE }

Functions
static int	barrier_init (barrier_t *b, uint32_t count)
static void	cleanup_barrier (void *arg)
static int	barrier_wait (barrier_t *b)
static int	pin_cpu (uint32_t cpu)
static void	pfms_thread_mainloop (void *arg)
static int	create_one_wthread (int cpu)
static int	create_wthreads (uint64_t *cpu_list, uint32_t n)
int	pfms_initialize (void)
int	pfms_create (uint64_t *cpu_list, size_t n, pfarg_ctx_t *ctx, pfms_ovfl_t *ovfl, void **desc)
int	pfms_load (void *desc)
static int	__pfms_do_simple_cmd (pfms_cmd_t cmd, void *desc, void *data, uint32_t n)
int	pfms_unload (void *desc)
int	pfms_start (void *desc)
int	pfms_stop (void *desc)
int	pfms_write_pmcs (void *desc, pfarg_pmc_t *pmcs, uint32_t n)
int	pfms_write_pmds (void *desc, pfarg_pmd_t *pmds, uint32_t n)
int	pfms_close (void *desc)
int	pfms_read_pmds (void *desc, pfarg_pmd_t *pmds, uint32_t n)

Variables
static uint32_t	ncpus
static pfms_thread_t *	tds
static pthread_mutex_t	tds_lock = PTHREAD_MUTEX_INITIALIZER

Macro Definition Documentation

dprint

#define dprint	(		format,
			arg...
	)

Definition at line 18 of file libpfms.c.

Enumeration Type Documentation

pfms_cmd_t

enum pfms_cmd_t

Enumerator
CMD_NONE
CMD_CTX
CMD_LOAD
CMD_UNLOAD
CMD_WPMCS
CMD_WPMDS
CMD_RPMDS
CMD_STOP
CMD_START
CMD_CLOSE

Definition at line 20 of file libpfms.c.

             {  CMD_NONE,
        CMD_CTX,
        CMD_LOAD,
        CMD_UNLOAD,
        CMD_WPMCS,
        CMD_WPMDS,
        CMD_RPMDS,
        CMD_STOP,
        CMD_START,
        CMD_CLOSE
} pfms_cmd_t;

Function Documentation

__pfms_do_simple_cmd()

static int __pfms_do_simple_cmd ( pfms_cmd_t  cmd, void *  desc, void *  data, uint32_t  n  )

static

Definition at line 528 of file libpfms.c.

{
    size_t k;
    pfms_session_t *s;
    int ret;
 
    if (desc == NULL) {
        dprint("invalid parameters\n");
        return -1;
    }
    s = (pfms_session_t *)desc;
 
    if (s->ncpus == 0) {
        dprint("invalid session content 0 CPUS\n");
        return -1;
    }
    /*
     * send create context order
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            tds[k].cmd  = cmd;
            tds[k].data = data;
            tds[k].ndata = n;
            sem_post(&tds[k].cmd_sem);
        }
    }
    barrier_wait(&s->barrier);
 
    ret = 0;
 
    /*
     * check for errors
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            ret = tds[k].ret;
            if (ret) {
                dprint("failure on CPU%zu\n", k);
                break;
            }
        }
    }
    /*
     * simple commands cannot be undone
     */
    return ret ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

barrier_init()

static int barrier_init ( barrier_t *  b, uint32_t  count  )

static

Definition at line 68 of file libpfms.c.

{
    int r;
 
    r = pthread_mutex_init(&b->mutex, NULL);
    if (r == -1) return -1;
 
    r = pthread_cond_init(&b->cond, NULL);
    if (r == -1) return -1;
 
    b->max = b->counter = count;
    b->generation = 0;
 
    return 0;
}

Here is the caller graph for this function:

barrier_wait()

static int barrier_wait ( barrier_t *  b )

static

Definition at line 95 of file libpfms.c.

{
    uint64_t generation;
    int oldstate;
 
    pthread_cleanup_push(cleanup_barrier, b);
 
    pthread_mutex_lock(&b->mutex);
 
    pthread_testcancel();
 
    if (--b->counter == 0) {
 
        /* reset barrier */
        b->counter = b->max;
        /*
         * bump generation number, this avoids thread getting stuck in the
         * wake up loop below in case a thread just out of the barrier goes
         * back in right away before all the thread from the previous "round"
         * have "escaped".
         */
        b->generation++;
 
        pthread_cond_broadcast(&b->cond);
    } else {
 
        generation = b->generation;
 
        pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, &oldstate);
 
        while (b->counter != b->max && generation == b->generation) {
            pthread_cond_wait(&b->cond, &b->mutex);
        }
 
        pthread_setcancelstate(oldstate, NULL);
    }
    pthread_mutex_unlock(&b->mutex);
 
    pthread_cleanup_pop(0);
 
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cleanup_barrier()

static void cleanup_barrier ( void *  arg )

static

Definition at line 85 of file libpfms.c.

{
    barrier_t *b = (barrier_t *)arg;
    int r;
    r = pthread_mutex_unlock(&b->mutex);
    dprint("free barrier mutex r=%d\n", r);
    (void) r;
}

Here is the caller graph for this function:

create_one_wthread()

static int create_one_wthread ( int  cpu )

static

Definition at line 260 of file libpfms.c.

{
    int ret;
 
    sem_init(&tds[cpu].cmd_sem, 0, 0);
 
    ret = pthread_create(&tds[cpu].tid, 
                 NULL, 
                 (void *(*)(void *))pfms_thread_mainloop,
                 (void *)(long)cpu);
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

create_wthreads()

static int create_wthreads ( uint64_t *  cpu_list, uint32_t  n  )

static

Definition at line 277 of file libpfms.c.

{
    uint64_t v;
    uint32_t i,k, cpu;
    int ret = 0;
 
    for(k=0, cpu = 0; k < n; k++, cpu+= 64) {
        v = cpu_list[k];
        for(i=0; v && i < 63; i++, v>>=1, cpu++) {
            if ((v & 0x1) && tds[cpu].tid == 0) {
                ret = create_one_wthread(cpu);
                if (ret) break;
            }
        }
    }
 
    if (ret)
        dprint("cannot create wthread on CPU%u\n", cpu);
 
    return ret;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_close()

int pfms_close

(

void *

desc

)

Definition at line 608 of file libpfms.c.

{
    size_t k;
    pfms_session_t *s;
    int ret;
 
    if (desc == NULL) {
        dprint("invalid parameters\n");
        return -1;
    }
    s = (pfms_session_t *)desc;
 
    if (s->ncpus == 0) {
        dprint("invalid session content 0 CPUS\n");
        return -1;
    }
 
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            tds[k].cmd  = CMD_CLOSE;
            sem_post(&tds[k].cmd_sem);
        }
    }
    barrier_wait(&s->barrier);
 
    ret = 0;
 
    pthread_mutex_lock(&tds_lock);
    /*
     * check for errors
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            if (tds[k].ret) {
                dprint("failure on CPU%zu\n", k);
            }
            ret |= tds[k].ret;
            tds[k].barrier = NULL;
        }
    }
 
    pthread_mutex_unlock(&tds_lock);
 
    free(s);
 
    /*
     * XXX: we cannot undo close
     */
    return ret ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_create()

int pfms_create	(	uint64_t *	cpu_list,
		size_t	n,
		pfarg_ctx_t *	ctx,
		pfms_ovfl_t *	ovfl,
		void **	desc
	)

Definition at line 327 of file libpfms.c.

{
    uint64_t v;
    size_t k, i;
    uint32_t num, cpu;
    pfms_session_t *s;
    int ret;
 
    if (cpu_list == NULL || n == 0 || ctx == NULL || desc == NULL) {
        dprint("invalid parameters\n");
        return -1;
    }
 
    if ((ctx->ctx_flags & PFM_FL_SYSTEM_WIDE) == 0) {
        dprint("only works for system wide\n");
        return -1;
    }
 
    *desc = NULL;
 
    /*
     * XXX: assuming CPU are contiguously indexed
     */
    num = 0;
    for(k=0, cpu = 0; k < n; k++, cpu+=64) {
        v = cpu_list[k];
        for(i=0; v && i < 63; i++, v>>=1, cpu++) {
            if (v & 0x1) {
                if (cpu >= ncpus) {
                    dprint("unavailable CPU%u\n", cpu);
                    return -1;
                }
                num++;
            }
        }
    }
 
    if (num == 0)
        return 0;
 
    s = calloc(1, sizeof(*s));
    if (s == NULL) {
        dprint("cannot allocate %u contexts\n", num);
        return -1;
    }
    s->ncpus = num;
 
    printf("%u-way  session\n", num);
 
    /*
     * +1 to account for main thread waiting
     */
    ret = barrier_init(&s->barrier, num + 1);
    if (ret) {
        dprint("cannot init barrier\n");
        goto error_free;
    }
 
    /*
     * lock thread descriptor table, no other create_session, close_session
     * can occur
     */
    pthread_mutex_lock(&tds_lock);
 
    if (create_wthreads(cpu_list, n))
        goto error_free_unlock;
 
    /*
     * check all needed threads are available
     */
    for(k=0, cpu = 0; k < n; k++, cpu += 64) {
        v = cpu_list[k];
        for(i=0; v && i < 63; i++, v>>=1, cpu++) {
            if (v & 0x1) {
                if (tds[cpu].barrier) {
                    dprint("CPU%u already managing a session\n", cpu);
                    goto error_free_unlock;
                }
 
            }
        }
    }
 
    /*
     * send create context order
     */
    for(k=0, cpu = 0; k < n; k++, cpu += 64) {
        v = cpu_list[k];
        for(i=0; v && i < 63; i++, v>>=1, cpu++) {
            if (v & 0x1) {
                tds[cpu].cmd  = CMD_CTX;
                tds[cpu].data = ctx;
                tds[cpu].barrier = &s->barrier;
                sem_post(&tds[cpu].cmd_sem);
            }
        }
    }
    barrier_wait(&s->barrier);
 
    ret = 0;
 
    /*
     * check for errors
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            ret = tds[k].ret;
            if (ret)
                break;
        }
    }
    /*
     * undo if error found
     */
    if (k < ncpus) {
        for(k=0; k < ncpus; k++) {
            if (tds[k].barrier == &s->barrier) {
                if (tds[k].ret == 0) {
                    tds[k].cmd = CMD_CLOSE;
                    sem_post(&tds[k].cmd_sem);
                }
                /* mark as free */
                tds[k].barrier = NULL;
            }
        }
    }
    pthread_mutex_unlock(&tds_lock);
 
    if (ret == 0) *desc = s;
 
    return ret ? -1 : 0;
 
error_free_unlock:
    pthread_mutex_unlock(&tds_lock);
 
error_free:
    free(s);
    return -1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_initialize()

int pfms_initialize

(

void

)

Definition at line 300 of file libpfms.c.

{
    printf("cpu_t=%zu thread=%zu session_t=%zu\n",
        sizeof(pfms_cpu_t),
        sizeof(pfms_thread_t),
        sizeof(pfms_session_t));
 
    ncpus = (uint32_t)sysconf(_SC_NPROCESSORS_ONLN);
    if (ncpus == -1) {
        dprint("cannot retrieve number of online processors\n");
        return -1;
    }
 
    dprint("configured for %u CPUs\n", ncpus);
 
    /*
     * XXX: assuming CPU are contiguously indexed
     */
    tds = calloc(ncpus, sizeof(*tds));
    if (tds == NULL) {
        dprint("cannot allocate thread descriptors\n");
        return -1;
    }
    return 0;
}

Here is the caller graph for this function:

pfms_load()

int pfms_load

(

void *

desc

)

Definition at line 468 of file libpfms.c.

{
    uint32_t k;
    pfms_session_t *s;
    int ret;
 
    if (desc == NULL) {
        dprint("invalid parameters\n");
        return -1;
    }
    s = (pfms_session_t *)desc;
 
    if (s->ncpus == 0) {
        dprint("invalid session content 0 CPUS\n");
        return -1;
    }
    /*
     * send create context order
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            tds[k].cmd  = CMD_LOAD;
            sem_post(&tds[k].cmd_sem);
        }
    }
 
    barrier_wait(&s->barrier);
 
    ret = 0;
 
    /*
     * check for errors
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            ret = tds[k].ret;
            if (ret) {
                dprint("failure on CPU%u\n", k);
                break;
            }
        }
    }
 
    /*
     * if error, unload all others
     */
    if (k < ncpus) {
        for(k=0; k < ncpus; k++) {
            if (tds[k].barrier == &s->barrier) {
                if (tds[k].ret == 0) {
                    tds[k].cmd = CMD_UNLOAD;
                    sem_post(&tds[k].cmd_sem);
                }
            }
        }
    }
    return ret ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_read_pmds()

int pfms_read_pmds	(	void *	desc,
		pfarg_pmd_t *	pmds,
		uint32_t	n
	)

Definition at line 660 of file libpfms.c.

{
    pfms_session_t *s;
    uint32_t k, pmds_per_cpu;
    int ret;
 
    if (desc == NULL) {
        dprint("invalid parameters\n");
        return -1;
    }
    s = (pfms_session_t *)desc;
 
    if (s->ncpus == 0) {
        dprint("invalid session content 0 CPUS\n");
        return -1;
    }
    if (n % s->ncpus) {
        dprint("invalid number of pfarg_pmd_t provided, must be multiple of %u\n", s->ncpus);
        return -1;
    }
    pmds_per_cpu = n / s->ncpus;
 
    dprint("n=%u ncpus=%u per_cpu=%u\n", n, s->ncpus, pmds_per_cpu);
 
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            tds[k].cmd  = CMD_RPMDS;
            tds[k].data = pmds;
            tds[k].ndata= pmds_per_cpu;
            sem_post(&tds[k].cmd_sem);
            pmds += pmds_per_cpu;
        }
    }
    barrier_wait(&s->barrier);
 
    ret = 0;
 
    /*
     * check for errors
     */
    for(k=0; k < ncpus; k++) {
        if (tds[k].barrier == &s->barrier) {
            ret = tds[k].ret;
            if (ret) {
                dprint("failure on CPU%u\n", k);
                break;
            }
        }
    }
    /*
     * cannot undo pfm_read_pmds
     */
    return ret ? -1 : 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_start()

int pfms_start

(

void *

desc

)

Definition at line 584 of file libpfms.c.

{
    return __pfms_do_simple_cmd(CMD_START, desc, NULL, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_stop()

int pfms_stop

(

void *

desc

)

Definition at line 590 of file libpfms.c.

{
    return __pfms_do_simple_cmd(CMD_STOP, desc, NULL, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_thread_mainloop()

static void pfms_thread_mainloop ( void *  arg )

static

Definition at line 172 of file libpfms.c.

{
    long k = (long )arg;
    uint32_t mycpu = (uint32_t)k;
    pfarg_ctx_t myctx, *ctx;
    pfarg_load_t load_args;
    int fd = -1;
    pfms_thread_t *td;
    sem_t *cmd_sem;
    int ret = 0;
 
    memset(&load_args, 0, sizeof(load_args));
    load_args.load_pid = mycpu;
    td = tds+mycpu;
 
    ret = pin_cpu(mycpu);
    dprint("CPU%u wthread created and pinned ret=%d\n", mycpu, ret);
 
    cmd_sem = &tds[mycpu].cmd_sem;
 
    for(;;) {
        dprint("CPU%u waiting for cmd\n", mycpu);
 
        sem_wait(cmd_sem);
 
        switch(td->cmd) {
            case CMD_NONE:
                ret = 0;
                break;
 
            case CMD_CTX:
 
                /*
                 * copy context to get private fd
                 */
                ctx = td->data;
                myctx = *ctx;
 
                fd = pfm_create_context(&myctx, NULL, NULL, 0);
                ret = fd < 0 ? -1 : 0;
                dprint("CPU%u CMD_CTX ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
 
            case CMD_LOAD:
                ret = pfm_load_context(fd, &load_args);
                dprint("CPU%u CMD_LOAD ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_UNLOAD:
                ret = pfm_unload_context(fd);
                dprint("CPU%u CMD_UNLOAD ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_START:
                ret = pfm_start(fd, NULL);
                dprint("CPU%u CMD_START ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_STOP:
                ret = pfm_stop(fd);
                dprint("CPU%u CMD_STOP ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_WPMCS:
                ret = pfm_write_pmcs(fd,(pfarg_pmc_t *)td->data, td->ndata);
                dprint("CPU%u CMD_WPMCS ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_WPMDS:
                ret = pfm_write_pmds(fd,(pfarg_pmd_t *)td->data, td->ndata);
                dprint("CPU%u CMD_WPMDS ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_RPMDS:
                ret = pfm_read_pmds(fd,(pfarg_pmd_t *)td->data, td->ndata);
                dprint("CPU%u CMD_RPMDS ret=%d errno=%d fd=%d\n", mycpu, ret, errno, fd);
                break;
            case CMD_CLOSE:
                dprint("CPU%u CMD_CLOSE fd=%d\n", mycpu, fd);
                ret = close(fd);
                fd = -1;
                break;
            default:
                break;
        }
        td->ret = ret;
 
        dprint("CPU%u td->ret=%d\n", mycpu, ret);
 
        barrier_wait(td->barrier);
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_unload()

int pfms_unload

(

void *

desc

)

Definition at line 578 of file libpfms.c.

{
    return __pfms_do_simple_cmd(CMD_UNLOAD, desc, NULL, 0);
}

Here is the call graph for this function:

pfms_write_pmcs()

int pfms_write_pmcs	(	void *	desc,
		pfarg_pmc_t *	pmcs,
		uint32_t	n
	)

Definition at line 596 of file libpfms.c.

{
    return __pfms_do_simple_cmd(CMD_WPMCS, desc, pmcs, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pfms_write_pmds()

int pfms_write_pmds	(	void *	desc,
		pfarg_pmd_t *	pmds,
		uint32_t	n
	)

Definition at line 602 of file libpfms.c.

{
    return __pfms_do_simple_cmd(CMD_WPMDS, desc, pmds, n);
}

Here is the call graph for this function:

Here is the caller graph for this function:

pin_cpu()

static int pin_cpu ( uint32_t  cpu )

static

Definition at line 146 of file libpfms.c.

{
    uint64_t *mask;
    size_t size;
    pid_t pid;
    int ret;
 
    pid = syscall(__NR_gettid);
 
    size = ncpus * sizeof(uint64_t);
 
    mask = calloc(1, size);
    if (mask == NULL) {
        dprint("CPU%u: cannot allocate bitvector\n", cpu);
        return -1;
    }
    mask[cpu>>6] = 1ULL << (cpu & 63);
 
    ret = syscall(__NR_sched_setaffinity, pid, size, mask);
 
    free(mask);
 
    return ret;
}

Here is the caller graph for this function:

Variable Documentation

ncpus

uint32_t ncpus

static

Definition at line 63 of file libpfms.c.

tds

pfms_thread_t* tds

static

Definition at line 64 of file libpfms.c.

tds_lock

pthread_mutex_t tds_lock = PTHREAD_MUTEX_INITIALIZER

static

Definition at line 65 of file libpfms.c.