libpfms.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs
typedef int(*	pfms_ovfl_t) (pfarg_msg_t *msg)

Functions
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_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_read_pmds (void *desc, pfarg_pmd_t *pmds, uint32_t n)
int	pfms_start (void *desc)
int	pfms_stop (void *desc)
int	pfms_close (void *desc)
int	pfms_unload (void *desc)
int	pfms_load (void *desc)

Typedef Documentation

pfms_ovfl_t

typedef int(* pfms_ovfl_t) (pfarg_msg_t *msg)

Definition at line 31 of file libpfms.h.

Function Documentation

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_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: