Lines Matching refs:cpu
101 struct pmc_cpu **pmc_pcpu; /* per-cpu state */
215 int cpu);
217 static void pmc_capture_user_callchain(int cpu, int soft, struct trapframe *tf);
245 static void pmc_process_samples(int cpu, ring_type_t soft);
254 static void pmc_select_cpu(int cpu);
309 pmc_cpuid, 0, "cpu version string");
471 DBG_SET_FLAG_MAJ("cpu", CPU);
631 * - per-cpu hardware state
702 * the per-cpu phw array. The 'runcount' for the PMC is
737 * save the cpu binding of the current kthread
743 PMCDBG0(CPU,BND,2, "save-cpu");
748 PMCDBG1(CPU,BND,2, "save-cpu cpu=%d", pb->pb_cpu);
752 * restore the cpu binding of the current thread
758 PMCDBG2(CPU,BND,2, "restore-cpu curcpu=%d restore=%d",
766 PMCDBG0(CPU,BND,2, "restore-cpu done");
770 * move execution over the specified cpu and bind it there.
774 pmc_select_cpu(int cpu)
776 KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
777 ("[pmc,%d] bad cpu number %d", __LINE__, cpu));
780 KASSERT(pmc_cpu_is_active(cpu), ("[pmc,%d] selecting inactive "
781 "CPU %d", __LINE__, cpu));
783 PMCDBG1(CPU,SEL,2, "select-cpu cpu=%d", cpu);
785 sched_bind(curthread, cpu);
788 KASSERT(curthread->td_oncpu == cpu,
789 ("[pmc,%d] CPU not bound [cpu=%d, curr=%d]", __LINE__,
790 cpu, curthread->td_oncpu));
792 PMCDBG1(CPU,SEL,2, "select-cpu cpu=%d ok", cpu);
1347 int cpu;
1368 cpu = PCPU_GET(cpuid); /* td->td_oncpu is invalid */
1370 PMCDBG5(CSW,SWI,1, "cpu=%d proc=%p (%d, %s) pp=%p", cpu, p,
1373 KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
1374 ("[pmc,%d] weird CPU id %d", __LINE__, cpu));
1376 pc = pmc_pcpu[cpu];
1408 pcd->pcd_config_pmc(cpu, adjri, pm);
1467 ("[pmc,%d] pmcval outside of expected range cpu=%d "
1469 cpu, ri, newvalue, pm->pm_sc.pm_reloadcount));
1475 newvalue = PMC_PCPU_SAVED(cpu, ri) =
1480 PMCDBG3(CSW,SWI,1,"cpu=%d ri=%d new=%jd", cpu, ri, newvalue);
1482 pcd->pcd_write_pmc(cpu, adjri, newvalue);
1486 pm->pm_pcpu_state[cpu].pps_stalled = 0;
1489 pm->pm_pcpu_state[cpu].pps_cpustate = 1;
1492 pcd->pcd_start_pmc(cpu, adjri);
1496 * perform any other architecture/cpu dependent thread
1513 int cpu;
1549 cpu = PCPU_GET(cpuid); /* td->td_oncpu is invalid */
1551 PMCDBG5(CSW,SWO,1, "cpu=%d proc=%p (%d, %s) pp=%p", cpu, p,
1554 KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
1555 ("[pmc,%d weird CPU id %d", __LINE__, cpu));
1557 pc = pmc_pcpu[cpu];
1574 (void) (*pcd->pcd_get_config)(cpu, adjri, &pm);
1593 pm->pm_pcpu_state[cpu].pps_cpustate = 0;
1594 if (pm->pm_pcpu_state[cpu].pps_stalled == 0)
1595 pcd->pcd_stop_pmc(cpu, adjri);
1619 pcd->pcd_read_pmc(cpu, adjri, &newvalue);
1622 PMCDBG3(CSW,SWO,1,"cpu=%d ri=%d val=%jd (samp)",
1623 cpu, ri, newvalue);
1667 tmp = newvalue - PMC_PCPU_SAVED(cpu,ri);
1669 PMCDBG3(CSW,SWO,1,"cpu=%d ri=%d tmp=%jd (count)",
1670 cpu, ri, tmp);
1679 ("[pmc,%d] negative increment cpu=%d "
1681 "incr=%jx", __LINE__, cpu, ri,
1682 newvalue, PMC_PCPU_SAVED(cpu,ri), tmp));
1695 pcd->pcd_config_pmc(cpu, adjri, NULL);
1699 * perform any other architecture/cpu dependent thread
2085 int cpu;
2229 * Clear the cpu specific bit in the CPU mask before
2240 cpu = PCPU_GET(cpuid);
2241 pmc_process_samples(cpu, PMC_HR);
2242 pmc_process_samples(cpu, PMC_SR);
2243 pmc_process_samples(cpu, PMC_UR);
2283 cpu = PCPU_GET(cpuid);
2284 pmc_capture_user_callchain(cpu, PMC_SR,
2771 u_int adjri, ri, cpu;
2792 cpu = 0;
2801 cpu = PMC_TO_CPU(pm);
2803 pmc_select_cpu(cpu);
2806 pm->pm_pcpu_state[cpu].pps_cpustate = 0;
2808 pm->pm_pcpu_state[cpu].pps_stalled == 0) {
2810 phw = pmc_pcpu[cpu]->pc_hwpmcs[ri];
2815 PMCDBG2(PMC,REL,2, "stopping cpu=%d ri=%d", cpu, ri);
2818 pcd->pcd_stop_pmc(cpu, adjri);
2822 PMCDBG2(PMC,REL,2, "decfg cpu=%d ri=%d", cpu, ri);
2825 pcd->pcd_config_pmc(cpu, adjri, NULL);
2845 * the per-cpu sample queues. Wait for the queue to
2892 cpu = curthread->td_oncpu; /* setup cpu for pmd_release() */
2899 (void) pcd->pcd_release_pmc(cpu, adjri, pm);
2976 pmc_can_allocate_rowindex(struct proc *p, unsigned int ri, int cpu)
2984 "cpu=%d", p, p->p_pid, p->p_comm, ri, cpu);
3000 (int) PMC_TO_CPU(pm) == cpu)
3137 int adjri, error, cpu, ri;
3225 cpu = PMC_TO_CPU(pm);
3227 if (!pmc_cpu_is_active(cpu))
3230 pmc_select_cpu(cpu);
3240 if ((error = pcd->pcd_write_pmc(cpu, adjri,
3246 pm->pm_pcpu_state[cpu].pps_stalled = 0;
3249 pm->pm_pcpu_state[cpu].pps_cpustate = 1;
3250 error = pcd->pcd_start_pmc(cpu, adjri);
3269 int adjri, cpu, error, ri;
3300 cpu = PMC_TO_CPU(pm);
3302 KASSERT(cpu >= 0 && cpu < pmc_cpu_max(),
3303 ("[pmc,%d] illegal cpu=%d", __LINE__, cpu));
3305 if (!pmc_cpu_is_active(cpu))
3308 pmc_select_cpu(cpu);
3313 pm->pm_pcpu_state[cpu].pps_cpustate = 0;
3315 if ((error = pcd->pcd_stop_pmc(cpu, adjri)) == 0)
3316 error = pcd->pcd_read_pmc(cpu, adjri, &pm->pm_sc.pm_initial);
3635 uint32_t cpu, n, npmc;
3646 if ((error = copyin(&gpi->pm_cpu, &cpu, sizeof(cpu))) != 0)
3649 if (cpu >= pmc_cpu_max()) {
3654 if (!pmc_cpu_is_active(cpu)) {
3659 /* switch to CPU 'cpu' */
3661 pmc_select_cpu(cpu);
3677 if ((error = pcd->pcd_describe(cpu, ari, p, &pm)) != 0)
3726 int cpu, ri;
3745 cpu = pma.pm_cpu;
3747 if (cpu < 0 || cpu >= (int) pmc_cpu_max()) {
3752 if (!pmc_cpu_is_active(cpu)) {
3788 pmc_select_cpu(cpu);
3790 pc = pmc_pcpu[cpu];
3823 u_int cpu;
3837 cpu = pa.pm_cpu;
3841 (cpu != (u_int) PMC_CPU_ANY && cpu >= pmc_cpu_max())) {
3851 if ((PMC_IS_VIRTUAL_MODE(mode) && cpu != (u_int) PMC_CPU_ANY) ||
3852 (PMC_IS_SYSTEM_MODE(mode) && cpu == (u_int) PMC_CPU_ANY)) {
3861 if (PMC_IS_SYSTEM_MODE(mode) && !pmc_cpu_is_active(cpu)) {
3938 PMCDBG4(PMC,ALL,2, "event=%d caps=0x%x mode=%d cpu=%d",
3939 pa.pm_ev, caps, mode, cpu);
3942 pmc->pm_id = PMC_ID_MAKE_ID(cpu,pa.pm_mode,pa.pm_class,
3962 /* switch thread to CPU 'cpu' */
3965 #define PMC_IS_SHAREABLE_PMC(cpu, n) \
3966 (pmc_pcpu[(cpu)]->pc_hwpmcs[(n)]->phw_state & \
3968 #define PMC_IS_UNALLOCATED(cpu, n) \
3969 (pmc_pcpu[(cpu)]->pc_hwpmcs[(n)]->phw_pmc == NULL)
3972 pmc_select_cpu(cpu);
3977 curthread->td_proc, n, cpu) == 0 &&
3978 (PMC_IS_UNALLOCATED(cpu, n) ||
3979 PMC_IS_SHAREABLE_PMC(cpu, n)) &&
3980 pcd->pcd_allocate_pmc(cpu, adjri, pmc,
4011 pmc->pm_id = PMC_ID_MAKE_ID(cpu,mode,pa.pm_class,n);
4031 pmc_select_cpu(cpu);
4033 phw = pmc_pcpu[cpu]->pc_hwpmcs[n];
4037 (error = pcd->pcd_config_pmc(cpu, adjri, pmc)) != 0) {
4038 (void) pcd->pcd_release_pmc(cpu, adjri, pmc);
4325 uint32_t cpu, ri;
4386 cpu = curthread->td_oncpu;
4391 error = (*pcd->pcd_read_pmc)(cpu, adjri,
4402 cpu = PMC_TO_CPU(pm);
4406 if (!pmc_cpu_is_active(cpu)) {
4411 /* move this thread to CPU 'cpu' */
4413 pmc_select_cpu(cpu);
4418 if ((error = (*pcd->pcd_read_pmc)(cpu, adjri,
4423 error = (*pcd->pcd_write_pmc)(cpu, adjri,
4654 * Find a free slot in the per-cpu array of samples and capture the
4666 int error, cpu, callchaindepth, inuserspace;
4676 cpu = curcpu;
4677 psb = pmc_pcpu[cpu]->pc_sb[ring];
4682 pm->pm_pcpu_state[cpu].pps_stalled = 1;
4684 PMCDBG6(SAM,INT,1,"(spc) cpu=%d pm=%p tf=%p um=%d wr=%d rd=%d",
4685 cpu, pm, (void *) tf, inuserspace,
4694 PMCDBG6(SAM,INT,1,"cpu=%d pm=%p tf=%p um=%d wr=%d rd=%d", cpu, pm,
4706 ps->ps_cpu = cpu;
4781 pmc_capture_user_callchain(int cpu, int ring, struct trapframe *tf)
4794 psb = pmc_pcpu[cpu]->pc_sb[ring];
4836 KASSERT(ps->ps_cpu == cpu,
4837 ("[pmc,%d] cpu mismatch ps_cpu=%d pcpu=%d", __LINE__,
4912 pmc_process_samples(int cpu, ring_type_t ring)
4923 KASSERT(PCPU_GET(cpuid) == cpu,
4924 ("[pmc,%d] not on the correct CPU pcpu=%d cpu=%d", __LINE__,
4925 PCPU_GET(cpuid), cpu));
4927 psb = pmc_pcpu[cpu]->pc_sb[ring];
4972 PMCDBG6(SAM,OPS,1,"cpu=%d pm=%p n=%d fl=%x wr=%d rd=%d", cpu,
5022 (void) (*pcd->pcd_get_config)(cpu,adjri,&pm);
5027 !pm->pm_pcpu_state[cpu].pps_cpustate || /* !desired */
5028 !pm->pm_pcpu_state[cpu].pps_stalled) /* !stalled */
5031 pm->pm_pcpu_state[cpu].pps_stalled = 0;
5032 (*pcd->pcd_start_pmc)(cpu, adjri);
5061 int adjri, cpu;
5106 cpu = curthread->td_oncpu;
5132 (void) (*pcd->pcd_get_config)(cpu, adjri, &pm);
5163 if (pm->pm_pcpu_state[cpu].pps_cpustate) {
5164 pm->pm_pcpu_state[cpu].pps_cpustate = 0;
5165 if (!pm->pm_pcpu_state[cpu].pps_stalled) {
5166 (void) pcd->pcd_stop_pmc(cpu, adjri);
5169 pcd->pcd_read_pmc(cpu, adjri,
5172 PMC_PCPU_SAVED(cpu,ri);
5190 (void) pcd->pcd_config_pmc(cpu, adjri, NULL);
5197 (void) md->pmd_switch_out(pmc_pcpu[cpu], pp);
5512 int c, cpu, error, n, ri;
5610 /* allocate space for the per-cpu array */
5614 /* per-cpu 'saved values' for managing process-mode PMCs */
5621 for (cpu = 0; error == 0 && cpu < maxcpu; cpu++) {
5622 if (!pmc_cpu_is_active(cpu))
5624 pmc_select_cpu(cpu);
5625 pmc_pcpu[cpu] = malloc(sizeof(struct pmc_cpu) +
5629 error = md->pmd_pcpu_init(md, cpu);
5631 error = md->pmd_classdep[n].pcd_pcpu_init(md, cpu);
5639 for (cpu = 0; cpu < maxcpu; cpu++) {
5640 if (!pmc_cpu_is_active(cpu))
5642 pc = pcpu_find(cpu);
5648 KASSERT(pmc_pcpu[cpu] != NULL,
5649 ("[pmc,%d] cpu=%d Null per-cpu data", __LINE__, cpu));
5659 pmc_pcpu[cpu]->pc_sb[PMC_HR] = sb;
5672 pmc_pcpu[cpu]->pc_sb[PMC_SR] = sb;
5683 pmc_pcpu[cpu]->pc_sb[PMC_UR] = sb;
5765 int c, cpu;
5777 CPU_FOREACH(cpu)
5778 DPCPU_ID_SET(cpu, pmc_sampled, 0);
5859 for (cpu = 0; cpu < maxcpu; cpu++) {
5860 PMCDBG2(MOD,INI,1,"pmc-cleanup cpu=%d pcs=%p",
5861 cpu, pmc_pcpu[cpu]);
5862 if (!pmc_cpu_is_active(cpu) || pmc_pcpu[cpu] == NULL)
5864 pmc_select_cpu(cpu);
5866 md->pmd_classdep[c].pcd_pcpu_fini(md, cpu);
5868 md->pmd_pcpu_fini(md, cpu);
5881 /* Free per-cpu descriptors. */
5882 for (cpu = 0; cpu < maxcpu; cpu++) {
5883 if (!pmc_cpu_is_active(cpu))
5885 KASSERT(pmc_pcpu[cpu]->pc_sb[PMC_HR] != NULL,
5886 ("[pmc,%d] Null hw cpu sample buffer cpu=%d", __LINE__,
5887 cpu));
5888 KASSERT(pmc_pcpu[cpu]->pc_sb[PMC_SR] != NULL,
5889 ("[pmc,%d] Null sw cpu sample buffer cpu=%d", __LINE__,
5890 cpu));
5891 KASSERT(pmc_pcpu[cpu]->pc_sb[PMC_UR] != NULL,
5892 ("[pmc,%d] Null userret cpu sample buffer cpu=%d", __LINE__,
5893 cpu));
5894 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_HR]->ps_callchains, M_PMC);
5895 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_HR], M_PMC);
5896 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_SR]->ps_callchains, M_PMC);
5897 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_SR], M_PMC);
5898 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_UR]->ps_callchains, M_PMC);
5899 free_domain(pmc_pcpu[cpu]->pc_sb[PMC_UR], M_PMC);
5900 free_domain(pmc_pcpu[cpu], M_PMC);