[BACK]Return to subr_pool.c CVS log [TXT][DIR] Up to [cvs.NetBSD.org] / src / sys / kern

Please note that diffs are not public domain; they are subject to the copyright notices on the relevant files.

Diff for /src/sys/kern/subr_pool.c between version 1.128.2.7 and 1.128.2.8

version 1.128.2.7, 2007/09/01 12:55:15 version 1.128.2.8, 2007/09/09 23:17:14
Line 2097  pool_cache_cpu_init1(struct cpu_info *ci
Line 2097  pool_cache_cpu_init1(struct cpu_info *ci
         cc->cc_misses = 0;          cc->cc_misses = 0;
         cc->cc_current = NULL;          cc->cc_current = NULL;
         cc->cc_previous = NULL;          cc->cc_previous = NULL;
         cc->cc_busy = NULL;  
   
         pc->pc_cpus[ci->ci_index] = cc;          pc->pc_cpus[ci->ci_index] = cc;
 }  }
Line 2138  pool_cache_reclaim(pool_cache_t pc)
Line 2137  pool_cache_reclaim(pool_cache_t pc)
         return pool_reclaim(&pc->pc_pool);          return pool_reclaim(&pc->pc_pool);
 }  }
   
 static inline void *  
 pcg_get(pcg_t *pcg, paddr_t *pap)  
 {  
         void *object;  
         u_int idx;  
   
         KASSERT(pcg->pcg_avail <= PCG_NOBJECTS);  
         KASSERT(pcg->pcg_avail != 0);  
   
         idx = --pcg->pcg_avail;  
         object = pcg->pcg_objects[idx].pcgo_va;  
         if (pap != NULL)  
                 *pap = pcg->pcg_objects[idx].pcgo_pa;  
   
 #ifdef DIAGNOSTIC  
         pcg->pcg_objects[idx].pcgo_va = NULL;  
         KASSERT(object != NULL);  
 #endif  
   
         return (object);  
 }  
   
 static inline void  
 pcg_put(pcg_t *pcg, void *object, paddr_t pa)  
 {  
         u_int idx;  
   
         idx = pcg->pcg_avail++;  
   
         KASSERT(pcg->pcg_avail <= PCG_NOBJECTS);  
         KASSERT(pcg->pcg_objects[idx].pcgo_va == NULL);  
   
         pcg->pcg_objects[idx].pcgo_va = object;  
         pcg->pcg_objects[idx].pcgo_pa = pa;  
 }  
   
 /*  /*
  * pool_cache_destruct_object:   * pool_cache_destruct_object:
  *   *
Line 2206  pool_cache_invalidate_groups(pool_cache_
Line 2169  pool_cache_invalidate_groups(pool_cache_
   
                 for (i = 0; i < pcg->pcg_avail; i++) {                  for (i = 0; i < pcg->pcg_avail; i++) {
                         object = pcg->pcg_objects[i].pcgo_va;                          object = pcg->pcg_objects[i].pcgo_va;
                         if (pc->pc_dtor != NULL)                          pool_cache_destruct_object(pc, object);
                                 (*pc->pc_dtor)(pc->pc_arg, object);  
                         pool_put(&pc->pc_pool, object);  
                 }                  }
   
                 pool_put(&pcgpool, pcg);                  pool_put(&pcgpool, pcg);
Line 2279  pool_cache_cpu_enter(pool_cache_t pc, in
Line 2240  pool_cache_cpu_enter(pool_cache_t pc, in
          * pull the neccessary information from CPU local data.           * pull the neccessary information from CPU local data.
          */           */
         ci = curcpu();          ci = curcpu();
           KASSERT(ci->ci_data.cpu_index < MAXCPUS);
         cc = pc->pc_cpus[ci->ci_data.cpu_index];          cc = pc->pc_cpus[ci->ci_data.cpu_index];
           KASSERT(cc->cc_cache == pc);
         if (cc->cc_ipl == IPL_NONE) {          if (cc->cc_ipl == IPL_NONE) {
                 crit_enter();                  crit_enter();
         } else {          } else {
Line 2293  pool_cache_cpu_enter(pool_cache_t pc, in
Line 2256  pool_cache_cpu_enter(pool_cache_t pc, in
         }          }
   
 #ifdef DIAGNOSTIC  #ifdef DIAGNOSTIC
         KASSERT(cc->cc_busy == NULL);  
         KASSERT(cc->cc_cpu == ci);          KASSERT(cc->cc_cpu == ci);
         KASSERT(((uintptr_t)cc & (CACHE_LINE_SIZE - 1)) == 0);          KASSERT(((uintptr_t)cc & (CACHE_LINE_SIZE - 1)) == 0);
         cc->cc_busy = curlwp;  
 #endif  #endif
   
         return cc;          return cc;
Line 2306  static inline void
Line 2267  static inline void
 pool_cache_cpu_exit(pool_cache_cpu_t *cc, int *s)  pool_cache_cpu_exit(pool_cache_cpu_t *cc, int *s)
 {  {
   
 #ifdef DIAGNOSTIC  
         KASSERT(cc->cc_busy == curlwp);  
         cc->cc_busy = NULL;  
 #endif  
   
         /* No longer need exclusive access to the per-CPU data. */          /* No longer need exclusive access to the per-CPU data. */
         if (cc->cc_ipl == IPL_NONE) {          if (cc->cc_ipl == IPL_NONE) {
                 crit_exit();                  crit_exit();
Line 2437  pool_cache_get_paddr(pool_cache_t pc, in
Line 2393  pool_cache_get_paddr(pool_cache_t pc, in
                 /* Try and allocate an object from the current group. */                  /* Try and allocate an object from the current group. */
                 pcg = cc->cc_current;                  pcg = cc->cc_current;
                 if (pcg != NULL && pcg->pcg_avail > 0) {                  if (pcg != NULL && pcg->pcg_avail > 0) {
                         object = pcg_get(pcg, pap);                          object = pcg->pcg_objects[--pcg->pcg_avail].pcgo_va;
                           if (pap != NULL)
                                   *pap = pcg->pcg_objects[pcg->pcg_avail].pcgo_pa;
                           pcg->pcg_objects[pcg->pcg_avail].pcgo_va = NULL;
                           KASSERT(pcg->pcg_avail <= PCG_NOBJECTS);
                           KASSERT(object != NULL);
                         cc->cc_hits++;                          cc->cc_hits++;
                         pool_cache_cpu_exit(cc, &s);                          pool_cache_cpu_exit(cc, &s);
                         FREECHECK_OUT(&pc->pc_freecheck, object);                          FREECHECK_OUT(&pc->pc_freecheck, object);
Line 2535  pool_cache_put_slow(pool_cache_cpu_t *cc
Line 2496  pool_cache_put_slow(pool_cache_cpu_t *cc
          * If we can't allocate a new group, just throw the           * If we can't allocate a new group, just throw the
          * object away.           * object away.
          */           */
 #ifdef XXXAD    /* Disable the cache layer for now. */  
         pcg = pool_get(&pcgpool, PR_NOWAIT);          pcg = pool_get(&pcgpool, PR_NOWAIT);
 #else  
         pcg = NULL;  
 #endif  
         if (pcg == NULL) {          if (pcg == NULL) {
                 pool_cache_destruct_object(pc, object);                  pool_cache_destruct_object(pc, object);
                 return NULL;                  return NULL;
Line 2582  pool_cache_put_paddr(pool_cache_t pc, vo
Line 2539  pool_cache_put_paddr(pool_cache_t pc, vo
                 /* If the current group isn't full, release it there. */                  /* If the current group isn't full, release it there. */
                 pcg = cc->cc_current;                  pcg = cc->cc_current;
                 if (pcg != NULL && pcg->pcg_avail < PCG_NOBJECTS) {                  if (pcg != NULL && pcg->pcg_avail < PCG_NOBJECTS) {
                         pcg_put(pcg, object, pa);                          KASSERT(pcg->pcg_objects[pcg->pcg_avail].pcgo_va
                               == NULL);
                           pcg->pcg_objects[pcg->pcg_avail].pcgo_va = object;
                           pcg->pcg_objects[pcg->pcg_avail].pcgo_pa = pa;
                           pcg->pcg_avail++;
                         cc->cc_hits++;                          cc->cc_hits++;
                         pool_cache_cpu_exit(cc, &s);                          pool_cache_cpu_exit(cc, &s);
                         return;                          return;

Legend:
Removed from v.1.128.2.7  
changed lines
  Added in v.1.128.2.8

CVSweb <webmaster@jp.NetBSD.org>