decay: separate fixed DecayRate from DecayCounter

Avoid eating a double per instance.

diff --git a/src/TODO b/src/TODO
index a96987eee6c46eea1260d7d381e932d98ef913a8..f7328fdd3452bd3df0e1b02b3440cae859d95ce1 100644 (file)
--- a/src/TODO
+++ b/src/TODO
@@ -77,12 +77,6 @@ bugs
 - osd pg split breaks if not all osds are up...
 - mislinked directory?  (cpusr.sh, mv /c/* /c/t, more cpusr, ls /c/t)
 
-?- kclient: after reconnect,
-cp: writing `/c/ceph2.2/bin/gs-gpl': Bad file descriptor
-  - need to somehow wake up unreconnected caps?   hrm!!
-
-?- kclient: socket creation
-
 - snaprealm thing
 ceph3:~# find /c
 /c

diff --git a/src/common/DecayCounter.h b/src/common/DecayCounter.h
index ca1b8b7d04620629aa53d8359939923e84b4af88..3c1722db72a537d032310bb395ac825fbbbaed3e 100644 (file)
--- a/src/common/DecayCounter.h
+++ b/src/common/DecayCounter.h
@@ -29,10 +29,22 @@
  *
  */
 
+class DecayRate {
+  double k;             // k = ln(.5)/half_life
+
+  friend class DecayCounter;
+
+public:
+  DecayRate() : k(0) {}
+  DecayRate(double hl) { set_halflife(hl); }
+  void set_halflife(double hl) {
+    k = log(.5) / hl;
+  }    
+};
+
 class DecayCounter {
  protected:
 public:
-  double k;             // k = ln(.5)/half_life
   double val;           // value
   double delta;         // delta since last decay
   double vel;           // recent velocity
@@ -41,9 +53,8 @@ public:
  public:
 
   void encode(bufferlist& bl) const {
-    __u8 struct_v = 2;
+    __u8 struct_v = 3;
     ::encode(struct_v, bl);
-    ::encode(k, bl);
     ::encode(val, bl);
     ::encode(delta, bl);
     ::encode(vel, bl);
@@ -55,18 +66,16 @@ public:
       double half_life;
       ::decode(half_life, p);
     }
-    ::decode(k, p);
+    if (struct_v < 3) {
+      double k;
+      ::decode(k, p);
+    }
     ::decode(val, p);
     ::decode(delta, p);
     ::decode(vel, p);
   }
 
   DecayCounter() : val(0), delta(0), vel(0) {
-    set_halflife( g_conf.mds_decay_halflife );
-    reset();
-  }
-  DecayCounter(double hl) : val(0), delta(0), vel(0) {
-    set_halflife( hl );
     reset();
   }
 
@@ -74,12 +83,8 @@ public:
    * reading
    */
 
-  double get() {
-    return get(g_clock.now());
-  }
-
-  double get(utime_t now) {
-    decay(now);
+  double get(utime_t now, const DecayRate& rate) {
+    decay(now, rate);
     return val;
   }
 
@@ -99,8 +104,8 @@ public:
    * adjusting
    */
 
-  double hit(utime_t now, double v = 1.0) {
-    decay(now);
+  double hit(utime_t now, const DecayRate& rate, double v = 1.0) {
+    decay(now, rate);
     delta += v;
     return val+delta;
   }
@@ -108,8 +113,8 @@ public:
   void adjust(double a) {
     val += a;
   }
-  void adjust(utime_t now, double a) {
-    decay(now);
+  void adjust(utime_t now, const DecayRate& rate, double a) {
+    decay(now, rate);
     val += a;
   }
   void scale(double f) {
@@ -122,10 +127,6 @@ public:
    * decay etc.
    */
 
-  void set_halflife(double hl) {
-    k = log(.5) / hl;
-  }
-
   void reset() {
     reset(g_clock.now());
   }
@@ -134,18 +135,18 @@ public:
     val = delta = 0;
   }
   
-  void decay(utime_t now) {
+  void decay(utime_t now, const DecayRate &rate) {
     utime_t el = now;
     el -= last_decay;
 
     if (el.sec() >= 1) {
       // calculate new value
-      double newval = (val+delta) * exp((double)el * k);
+      double newval = (val+delta) * exp((double)el * rate.k);
       if (newval < .01) newval = 0.0;
       
       // calculate velocity approx
       vel += (newval - val) * (double)el;
-      vel *= exp((double)el * k);
+      vel *= exp((double)el * rate.k);
       
       val = newval;
       delta = 0;

diff --git a/src/mds/CDir.cc b/src/mds/CDir.cc
index bf42fbd6ee539cde346475542d0e69bf55cbc930..5c80ce3bf45f8116ef612b31852c68a4fd88194b 100644 (file)
--- a/src/mds/CDir.cc
+++ b/src/mds/CDir.cc
@@ -672,15 +672,15 @@ void CDir::split(int bits, list<CDir*>& subs, list<Context*>& waiters, bool repl
     f->set_version(get_version());
 
     f->pop_me = pop_me;
-    f->pop_me *= fac;
+    f->pop_me.scale(fac);
 
     // FIXME; this is an approximation
     f->pop_nested = pop_nested;
-    f->pop_nested *= fac;
+    f->pop_nested.scale(fac);
     f->pop_auth_subtree = pop_auth_subtree;
-    f->pop_auth_subtree *= fac;
+    f->pop_auth_subtree.scale(fac);
     f->pop_auth_subtree_nested = pop_auth_subtree_nested;
-    f->pop_auth_subtree_nested *= fac;
+    f->pop_auth_subtree_nested.scale(fac);
 
     dout(10) << " subfrag " << *p << " " << *f << dendl;
     subfrags[n++] = f;
@@ -1743,14 +1743,14 @@ void CDir::encode_export(bufferlist& bl)
 
 void CDir::finish_export(utime_t now)
 {
-  pop_auth_subtree_nested -= pop_auth_subtree;
+  pop_auth_subtree_nested.sub(now, cache->decayrate, pop_auth_subtree);
   pop_me.zero(now);
   pop_auth_subtree.zero(now);
   put(PIN_TEMPEXPORTING);
   dirty_old_rstat.clear();
 }
 
-void CDir::decode_import(bufferlist::iterator& blp)
+void CDir::decode_import(bufferlist::iterator& blp, utime_t now)
 {
   ::decode(first, blp);
   ::decode(fnode, blp);
@@ -1769,7 +1769,7 @@ void CDir::decode_import(bufferlist::iterator& blp)
 
   ::decode(pop_me, blp);
   ::decode(pop_auth_subtree, blp);
-  pop_auth_subtree_nested += pop_auth_subtree;
+  pop_auth_subtree_nested.add(now, cache->decayrate, pop_auth_subtree);
 
   ::decode(dir_rep_by, blp);
   ::decode(replica_map, blp);

diff --git a/src/mds/CDir.h b/src/mds/CDir.h
index fb342e255086ce979be43b1695ce68d82b4c32aa..ae84ec9bb4a2414180cf52d07a995b6c39061b02 100644 (file)
--- a/src/mds/CDir.h
+++ b/src/mds/CDir.h
@@ -499,7 +499,7 @@ public:
   void abort_export() { 
     put(PIN_TEMPEXPORTING);
   }
-  void decode_import(bufferlist::iterator& blp);
+  void decode_import(bufferlist::iterator& blp, utime_t now);
 
 
   // -- auth pins --

diff --git a/src/mds/MDBalancer.cc b/src/mds/MDBalancer.cc
index 1b0b824f615f9832c64cc34961f1044a39f2de4a..23ed19c7b7a1d7558d009bbfd235cb56249ea3a3 100644 (file)
--- a/src/mds/MDBalancer.cc
+++ b/src/mds/MDBalancer.cc
@@ -140,7 +140,7 @@ double mds_load_t::mds_load()
   return 0;
 }
 
-mds_load_t MDBalancer::get_load()
+mds_load_t MDBalancer::get_load(utime_t now)
 {
   mds_load_t load;
 
@@ -150,8 +150,8 @@ mds_load_t MDBalancer::get_load()
     for (list<CDir*>::iterator p = ls.begin();
         p != ls.end();
         p++) {
-      load.auth += (*p)->pop_auth_subtree_nested;
-      load.all += (*p)->pop_nested;
+      load.auth.add(now, mds->mdcache->decayrate, (*p)->pop_auth_subtree_nested);
+      load.all.add(now, mds->mdcache->decayrate, (*p)->pop_nested);
     }
   } else {
     dout(20) << "get_load no root, no load" << dendl;
@@ -182,7 +182,7 @@ void MDBalancer::send_heartbeat()
     beat_epoch++;
 
   // my load
-  mds_load_t load = get_load();
+  mds_load_t load = get_load(now);
   mds_load[ mds->get_nodeid() ] = load;
 
   // import_map -- how much do i import from whom
@@ -196,7 +196,7 @@ void MDBalancer::send_heartbeat()
     int from = im->inode->authority().first;
     if (from == mds->get_nodeid()) continue;
     if (im->get_inode()->is_stray()) continue;
-    import_map[from] += im->pop_auth_subtree.meta_load(now);
+    import_map[from] += im->pop_auth_subtree.meta_load(now, mds->mdcache->decayrate);
   }
   mds_import_map[ mds->get_nodeid() ] = import_map;
   
@@ -359,7 +359,7 @@ void MDBalancer::prep_rebalance(int beat)
     // rescale!  turn my mds_load back into meta_load units
     double load_fac = 1.0;
     if (mds_load[whoami].mds_load() > 0) {
-      double metald = mds_load[whoami].auth.meta_load(rebalance_time);
+      double metald = mds_load[whoami].auth.meta_load(rebalance_time, mds->mdcache->decayrate);
       double mdsld = mds_load[whoami].mds_load();
       load_fac = metald / mdsld;
       dout(7) << " load_fac is " << load_fac 
@@ -530,7 +530,7 @@ void MDBalancer::try_rebalance()
       CDir *im = *it;
       if (im->get_inode()->is_stray()) continue;
 
-      double pop = im->pop_auth_subtree.meta_load(rebalance_time);
+      double pop = im->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate);
       if (g_conf.mds_bal_idle_threshold > 0 &&
          pop < g_conf.mds_bal_idle_threshold &&
          im->inode != mds->mdcache->get_root() &&
@@ -597,7 +597,7 @@ void MDBalancer::try_rebalance()
         
          if (dir->inode->is_root()) continue;
          if (dir->is_freezing() || dir->is_frozen()) continue;  // export pbly already in progress
-         double pop = dir->pop_auth_subtree.meta_load(rebalance_time);
+         double pop = dir->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate);
          assert(dir->inode->authority().first == target);  // cuz that's how i put it in the map, dummy
         
          if (pop <= amount-have) {
@@ -665,7 +665,7 @@ void MDBalancer::try_rebalance()
        dout(-5) << "   - exporting " 
                 << (*it)->pop_auth_subtree
                 << " "
-                << (*it)->pop_auth_subtree.meta_load(rebalance_time) 
+                << (*it)->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate) 
                 << " to mds" << target 
                 << " " << **it 
                 << dendl;
@@ -729,7 +729,7 @@ void MDBalancer::find_exports(CDir *dir,
   list<CDir*> bigger_rep, bigger_unrep;
   multimap<double, CDir*> smaller;
 
-  double dir_pop = dir->pop_auth_subtree.meta_load(rebalance_time);
+  double dir_pop = dir->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate);
   dout(7) << " find_exports in " << dir_pop << " " << *dir << " need " << need << " (" << needmin << " - " << needmax << ")" << dendl;
 
   double subdir_sum = 0;
@@ -752,7 +752,7 @@ void MDBalancer::find_exports(CDir *dir,
       if (subdir->is_frozen()) continue;  // can't export this right now!
       
       // how popular?
-      double pop = subdir->pop_auth_subtree.meta_load(rebalance_time);
+      double pop = subdir->pop_auth_subtree.meta_load(rebalance_time, mds->mdcache->decayrate);
       subdir_sum += pop;
       dout(15) << "   subdir pop " << pop << " " << *subdir << dendl;
 
@@ -833,7 +833,7 @@ void MDBalancer::find_exports(CDir *dir,
 void MDBalancer::hit_inode(utime_t now, CInode *in, int type, int who)
 {
   // hit inode
-  in->pop.get(type).hit(now);
+  in->pop.get(type).hit(now, mds->mdcache->decayrate);
 
   if (in->get_parent_dn())
     hit_dir(now, in->get_parent_dn()->get_dir(), type, who);
@@ -892,15 +892,15 @@ void MDBalancer::hit_dir(utime_t now, CDir *dir, int type, int who, double amoun
   
   // replicate?
   if (type == META_POP_IRD && who >= 0) {
-    dir->pop_spread.hit(now, who);
+    dir->pop_spread.hit(now, mds->mdcache->decayrate, who);
   }
 
   double rd_adj = 0;
   if (type == META_POP_IRD &&
       dir->last_popularity_sample < last_sample) {
-    float dir_pop = dir->pop_auth_subtree.get(type).get(now);    // hmm??
+    float dir_pop = dir->pop_auth_subtree.get(type).get(now, mds->mdcache->decayrate);    // hmm??
     dir->last_popularity_sample = last_sample;
-    float pop_sp = dir->pop_spread.get(now);
+    float pop_sp = dir->pop_spread.get(now, mds->mdcache->decayrate);
     dir_pop += pop_sp * 10;
 
     //if (dir->ino() == inodeno_t(0x10000000002))
@@ -917,7 +917,7 @@ void MDBalancer::hit_dir(utime_t now, CDir *dir, int type, int who, double amoun
       if (!dir->is_rep() &&
          dir_pop >= g_conf.mds_bal_replicate_threshold) {
        // replicate
-       float rdp = dir->pop_me.get(META_POP_IRD).get(now);
+       float rdp = dir->pop_me.get(META_POP_IRD).get(now, mds->mdcache->decayrate);
        rd_adj = rdp / mds->get_mds_map()->get_num_mds() - rdp; 
        rd_adj /= 2.0;  // temper somewhat
        
@@ -950,18 +950,18 @@ void MDBalancer::hit_dir(utime_t now, CDir *dir, int type, int who, double amoun
   while (1) {
     dir->pop_nested.get(type).hit(now, amount);
     if (rd_adj != 0.0) 
-      dir->pop_nested.get(META_POP_IRD).adjust(now, rd_adj);
+      dir->pop_nested.get(META_POP_IRD).adjust(now, mds->mdcache->decayrate, rd_adj);
     
     if (hit_subtree) {
       dir->pop_auth_subtree.get(type).hit(now, amount);
       if (rd_adj != 0.0) 
-       dir->pop_auth_subtree.get(META_POP_IRD).adjust(now, rd_adj);
+       dir->pop_auth_subtree.get(META_POP_IRD).adjust(now, mds->mdcache->decayrate, rd_adj);
     }
 
     if (hit_subtree_nested) {
-      dir->pop_auth_subtree_nested.get(type).hit(now, amount);
+      dir->pop_auth_subtree_nested.get(type).hit(now, mds->mdcache->decayrate, amount);
       if (rd_adj != 0.0) 
-       dir->pop_auth_subtree_nested.get(META_POP_IRD).adjust(now, rd_adj);
+       dir->pop_auth_subtree_nested.get(META_POP_IRD).adjust(now, mds->mdcache->decayrate, rd_adj);
     }  
     
     if (dir->is_subtree_root()) 
@@ -981,7 +981,7 @@ void MDBalancer::hit_dir(utime_t now, CDir *dir, int type, int who, double amoun
  * NOTE: call me _after_ forcing *dir into a subtree root,
  *       but _before_ doing the encode_export_dirs.
  */
-void MDBalancer::subtract_export(CDir *dir)
+void MDBalancer::subtract_export(CDir *dir, utime_t now)
 {
   dirfrag_load_vec_t subload = dir->pop_auth_subtree;
 
@@ -989,13 +989,13 @@ void MDBalancer::subtract_export(CDir *dir)
     dir = dir->inode->get_parent_dir();
     if (!dir) break;
     
-    dir->pop_nested -= subload;
-    dir->pop_auth_subtree_nested -= subload;
+    dir->pop_nested.sub(now, mds->mdcache->decayrate, subload);
+    dir->pop_auth_subtree_nested.sub(now, mds->mdcache->decayrate, subload);
   }
 }
     
 
-void MDBalancer::add_import(CDir *dir)
+void MDBalancer::add_import(CDir *dir, utime_t now)
 {
   dirfrag_load_vec_t subload = dir->pop_auth_subtree;
   
@@ -1003,8 +1003,8 @@ void MDBalancer::add_import(CDir *dir)
     dir = dir->inode->get_parent_dir();
     if (!dir) break;
     
-    dir->pop_nested += subload;
-    dir->pop_auth_subtree_nested += subload;
+    dir->pop_nested.add(now, mds->mdcache->decayrate, subload);
+    dir->pop_auth_subtree_nested.add(now, mds->mdcache->decayrate, subload);
   } 
 }
 
@@ -1057,10 +1057,10 @@ void MDBalancer::dump_pop_map()
           ++p) {
        CDir *dir = *p;
 
-       myfile << (int)dir->pop_me.meta_load(now) << "\t";
-       myfile << (int)dir->pop_nested.meta_load(now) << "\t";
-       myfile << (int)dir->pop_auth_subtree.meta_load(now) << "\t";
-       myfile << (int)dir->pop_auth_subtree_nested.meta_load(now) << "\t";
+       myfile << (int)dir->pop_me.meta_load(now, mds->mdcache->decayrate) << "\t";
+       myfile << (int)dir->pop_nested.meta_load(now, mds->mdcache->decayrate) << "\t";
+       myfile << (int)dir->pop_auth_subtree.meta_load(now, mds->mdcache->decayrate) << "\t";
+       myfile << (int)dir->pop_auth_subtree_nested.meta_load(now, mds->mdcache->decayrate) << "\t";
 
        // filename last
        string p;

diff --git a/src/mds/MDBalancer.h b/src/mds/MDBalancer.h
index 7238922998e76d5dabd12b1383411125a67d03f9..6c88f7e19fddd9c2c18f87fca501d8ed60a7155b 100644 (file)
--- a/src/mds/MDBalancer.h
+++ b/src/mds/MDBalancer.h
@@ -83,7 +83,7 @@ public:
     beat_epoch(0),
     last_epoch_under(0), last_epoch_over(0) { }
   
-  mds_load_t get_load();
+  mds_load_t get_load(utime_t);
 
   int proc_message(Message *m);
   
@@ -109,8 +109,8 @@ public:
                     set<CDir*>& already_exporting);
 
 
-  void subtract_export(class CDir *ex);
-  void add_import(class CDir *im);
+  void subtract_export(class CDir *ex, utime_t now);
+  void add_import(class CDir *im, utime_t now);
 
   void hit_inode(utime_t now, class CInode *in, int type, int who=-1);
   void hit_dir(utime_t now, class CDir *dir, int type, int who, double amount=1.0);

diff --git a/src/mds/MDCache.cc b/src/mds/MDCache.cc
index 8d1904032725809f2de641946d611993819035b7..473235309562f0f0f99206863085f00c2425a7c9 100644 (file)
--- a/src/mds/MDCache.cc
+++ b/src/mds/MDCache.cc
@@ -131,6 +131,8 @@ MDCache::MDCache(MDS *m)
   lru.lru_set_max(g_conf.mds_cache_size);
   lru.lru_set_midpoint(g_conf.mds_cache_mid);
 
+  decayrate.set_halflife(g_conf.mds_decay_halflife);
+
   did_shutdown_log_cap = false;
 }
 
@@ -707,9 +709,10 @@ void MDCache::adjust_subtree_auth(CDir *dir, pair<int,int> auth, bool do_eval)
 
     // adjust recursive pop counters
     if (dir->is_auth()) {
+      utime_t now = g_clock.now();
       CDir *p = dir->get_parent_dir();
       while (p) {
-       p->pop_auth_subtree -= dir->pop_auth_subtree;
+       p->pop_auth_subtree.sub(now, decayrate, dir->pop_auth_subtree);
        if (p->is_subtree_root()) break;
        p = p->inode->get_parent_dir();
       }
@@ -781,9 +784,10 @@ void MDCache::try_subtree_merge_at(CDir *dir)
 
     // adjust popularity?
     if (dir->is_auth()) {
+      utime_t now = g_clock.now();
       CDir *p = dir->get_parent_dir();
       while (p) {
-       p->pop_auth_subtree += dir->pop_auth_subtree;
+       p->pop_auth_subtree.add(now, decayrate, dir->pop_auth_subtree);
        if (p->is_subtree_root()) break;
        p = p->inode->get_parent_dir();
       }

diff --git a/src/mds/MDCache.h b/src/mds/MDCache.h
index 50087a099268a71a0d60a40001b775bd350f684f..8c1c28a826b91028ec08ca5db86aaa6a3a7940f9 100644 (file)
--- a/src/mds/MDCache.h
+++ b/src/mds/MDCache.h
@@ -445,6 +445,8 @@ class MDCache {
   CInode *stray;                           // my stray dir
 
 public:
+  DecayRate decayrate;
+
   int num_inodes_with_caps;
   int num_caps;
 

diff --git a/src/mds/MDS.cc b/src/mds/MDS.cc
index 190121408520406cd942c1eb826c116128525e45..ce48dd6a2fc4659b0f8af8509ada6bda8acbb2d9 100644 (file)
--- a/src/mds/MDS.cc
+++ b/src/mds/MDS.cc
@@ -449,7 +449,8 @@ void MDS::tick()
   }
 
   // log
-  mds_load_t load = balancer->get_load();
+  utime_t now = g_clock.now();
+  mds_load_t load = balancer->get_load(now);
   
   if (logger) {
     req_rate = logger->get(l_mds_req);

diff --git a/src/mds/Migrator.cc b/src/mds/Migrator.cc
index 62d3ac5b18e0bb049bc2f25a8b2e6cdb35cfa486..cf226639467eecd6dde0a925be2a473ca50f207d 100644 (file)
--- a/src/mds/Migrator.cc
+++ b/src/mds/Migrator.cc
@@ -818,6 +818,7 @@ void Migrator::export_go_synced(CDir *dir)
 {  
   assert(export_peer.count(dir));
   int dest = export_peer[dir];
+  utime_t now = g_clock.now();
   dout(7) << "export_go_synced " << *dir << " to " << dest << dendl;
 
   cache->show_subtrees();
@@ -832,11 +833,10 @@ void Migrator::export_go_synced(CDir *dir)
   cache->adjust_subtree_auth(dir, dest, mds->get_nodeid());
 
   // take away the popularity we're sending.
-  mds->balancer->subtract_export(dir);
+  mds->balancer->subtract_export(dir, now);
   
   // fill export message with cache data
   MExportDir *req = new MExportDir(dir->dirfrag());
-  utime_t now = g_clock.now();
   map<client_t,entity_inst_t> exported_client_map;
   int num_exported_inodes = encode_export_dir(req->export_data,
                                              dir,   // recur start point
@@ -1663,7 +1663,8 @@ void Migrator::handle_export_dir(MExportDir *m)
   assert (g_conf.mds_kill_import_at != 5);
   CDir *dir = cache->get_dirfrag(m->dirfrag);
   assert(dir);
-
+  
+  utime_t now = g_clock.now();
   int oldauth = m->get_source().num();
   dout(7) << "handle_export_dir importing " << *dir << " from " << oldauth << dendl;
   assert(dir->is_auth() == false);
@@ -1699,7 +1700,8 @@ void Migrator::handle_export_dir(MExportDir *m)
                        le,
                        mds->mdlog->get_current_segment(),
                        import_caps[dir],
-                       import_updated_scatterlocks[dir]);
+                       import_updated_scatterlocks[dir],
+                       now);
   }
   dout(10) << " " << m->bounds.size() << " imported bounds" << dendl;
   
@@ -1712,7 +1714,7 @@ void Migrator::handle_export_dir(MExportDir *m)
     le->metablob.add_dir(*it, false);  // note that parent metadata is already in the event
 
   // adjust popularity
-  mds->balancer->add_import(dir);
+  mds->balancer->add_import(dir, now);
 
   dout(7) << "handle_export_dir did " << *dir << dendl;
 
@@ -2101,7 +2103,7 @@ int Migrator::decode_import_dir(bufferlist::iterator& blp,
                                EImportStart *le,
                                LogSegment *ls,
                                map<CInode*, map<client_t,Capability::Export> >& cap_imports,
-                               list<ScatterLock*>& updated_scatterlocks)
+                               list<ScatterLock*>& updated_scatterlocks, utime_t now)
 {
   // set up dir
   dirfrag_t df;
@@ -2115,7 +2117,7 @@ int Migrator::decode_import_dir(bufferlist::iterator& blp,
   dout(7) << "decode_import_dir " << *dir << dendl;
 
   // assimilate state
-  dir->decode_import(blp);
+  dir->decode_import(blp, now);
 
   // mark  (may already be marked from get_or_open_dir() above)
   if (!dir->is_auth())

diff --git a/src/mds/Migrator.h b/src/mds/Migrator.h
index fc36bf3e5a0d40c4be28378bdeb59199a338b310..3debf202aa9e4ab042b32fefbb1a26392c4651fc 100644 (file)
--- a/src/mds/Migrator.h
+++ b/src/mds/Migrator.h
@@ -242,7 +242,7 @@ public:
                        EImportStart *le, 
                        LogSegment *ls,
                        map<CInode*, map<client_t,Capability::Export> >& cap_imports,
-                       list<ScatterLock*>& updated_scatterlocks);
+                       list<ScatterLock*>& updated_scatterlocks, utime_t now);
 
 public:
   void import_reverse(CDir *dir);

diff --git a/src/mds/mdstypes.h b/src/mds/mdstypes.h
index 64053cb8ca15892748ad4a2df53aa64b7f8e53f3..aff034095d5339229ace829bc286466ec7e31bf7 100644 (file)
--- a/src/mds/mdstypes.h
+++ b/src/mds/mdstypes.h
@@ -849,21 +849,21 @@ public:
     assert(t < NUM);
     return vec[t]; 
   }
-  void adjust(utime_t now, double d) {
+  void adjust(utime_t now, const DecayRate& rate, double d) {
     for (int i=0; i<NUM; i++) 
-      vec[i].adjust(now, d);
+      vec[i].adjust(now, rate, d);
   }
   void zero(utime_t now) {
     for (int i=0; i<NUM; i++) 
       vec[i].reset(now);
   }
-  double meta_load(utime_t now) {
+  double meta_load(utime_t now, const DecayRate& rate) {
     return 
-      1*vec[META_POP_IRD].get(now) + 
-      2*vec[META_POP_IWR].get(now) +
-      1*vec[META_POP_READDIR].get(now) +
-      2*vec[META_POP_FETCH].get(now) +
-      4*vec[META_POP_STORE].get(now);
+      1*vec[META_POP_IRD].get(now, rate) + 
+      2*vec[META_POP_IWR].get(now, rate) +
+      1*vec[META_POP_READDIR].get(now, rate) +
+      2*vec[META_POP_FETCH].get(now, rate) +
+      4*vec[META_POP_STORE].get(now, rate);
   }
   double meta_load() {
     return 
@@ -873,39 +873,30 @@ public:
       2*vec[META_POP_FETCH].get_last() +
       4*vec[META_POP_STORE].get_last();
   }
+
+  void add(utime_t now, DecayRate& rate, dirfrag_load_vec_t& r) {
+    for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+      vec[i].adjust(r.vec[i].get(now, rate));
+  }
+  void sub(utime_t now, DecayRate& rate, dirfrag_load_vec_t& r) {
+    for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+      vec[i].adjust(-r.vec[i].get(now, rate));
+  }
+  void scale(double f) {
+    for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
+      vec[i].scale(f);
+  }
 };
 
 WRITE_CLASS_ENCODER(dirfrag_load_vec_t)
 
-inline dirfrag_load_vec_t& operator+=(dirfrag_load_vec_t& l, dirfrag_load_vec_t& r)
-{
-  utime_t now = g_clock.now();
-  for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
-    l.vec[i].adjust(r.vec[i].get(now));
-  return l;
-}
-
-inline dirfrag_load_vec_t& operator-=(dirfrag_load_vec_t& l, dirfrag_load_vec_t& r)
-{
-  utime_t now = g_clock.now();
-  for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
-    l.vec[i].adjust(-r.vec[i].get(now));
-  return l;
-}
-
-inline dirfrag_load_vec_t& operator*=(dirfrag_load_vec_t& l, double f)
-{
-  for (int i=0; i<dirfrag_load_vec_t::NUM; i++)
-    l.vec[i].scale(f);
-  return l;
-}
-
-
 inline ostream& operator<<(ostream& out, dirfrag_load_vec_t& dl)
 {
+  // ugliness!
   utime_t now = g_clock.now();
-  return out << "[" << dl.vec[0].get(now) << "," << dl.vec[1].get(now) 
-            << " " << dl.meta_load(now)
+  DecayRate rate(g_conf.mds_decay_halflife);
+  return out << "[" << dl.vec[0].get(now, rate) << "," << dl.vec[1].get(now, rate) 
+            << " " << dl.meta_load(now, rate)
             << "]";
 }
 
@@ -996,10 +987,11 @@ public:
 
 public:
   load_spread_t() : p(0), n(0) { 
-    for (int i=0; i<MAX; i++) last[i] = -1;
+    for (int i=0; i<MAX; i++)
+      last[i] = -1;
   } 
 
-  double hit(utime_t now, int who) {
+  double hit(utime_t now, const DecayRate& rate, int who) {
     for (int i=0; i<n; i++)
       if (last[i] == who) 
        return count.get_last();
@@ -1011,10 +1003,10 @@ public:
 
     if (p == MAX) p = 0;
 
-    return count.hit(now);
+    return count.hit(now, rate);
   }
-  double get(utime_t now) {
-    return count.get(now);
+  double get(utime_t now, const DecayRate& rate) {
+    return count.get(now, rate);
   }
 };
 

diff --git a/src/osd/OSD.cc b/src/osd/OSD.cc
index 97d995e0f7f38a968c1717cc115b036f01d52580..17dddc30acb116699e5f00440d2e0d311dcf99b1 100644 (file)
--- a/src/osd/OSD.cc
+++ b/src/osd/OSD.cc
@@ -326,7 +326,8 @@ OSD::OSD(int id, Messenger *m, Messenger *hbm, MonClient *mc, const char *dev, c
   heartbeat_messenger(hbm),
   heartbeat_thread(this),
   heartbeat_dispatcher(this),
-  stat_oprate(5.0),
+  decayrate(5.0),
+  stat_oprate(),
   peer_stat_lock("OSD::peer_stat_lock"),
   read_latency_calc(g_conf.osd_max_opq<1 ? 1:g_conf.osd_max_opq),
   qlen_calc(3),
@@ -984,7 +985,7 @@ void OSD::_refresh_my_stat(utime_t now)
       pending_ops > 2*my_stat.qlen) {
 
     now.encode_timeval(&my_stat.stamp);
-    my_stat.oprate = stat_oprate.get(now);
+    my_stat.oprate = stat_oprate.get(now, decayrate);
 
     //read_latency_calc.set_size( 20 );  // hrm.
 
@@ -4076,7 +4077,7 @@ void OSD::handle_op(MOSDOp *op)
   PG *pg = _have_pg(pgid) ? _lookup_lock_pg(pgid):0;
 
   // update qlen stats
-  stat_oprate.hit(now);
+  stat_oprate.hit(now, decayrate);
   stat_ops++;
   stat_qlen += pending_ops;
 

diff --git a/src/osd/OSD.h b/src/osd/OSD.h
index f480b3505f1ddc295475c1541fc48e5e9068e0a7..e057b8cdf7ad38077a623f26a31ca44c51c26047 100644 (file)
--- a/src/osd/OSD.h
+++ b/src/osd/OSD.h
@@ -238,6 +238,7 @@ public:
 
 private:
   // -- stats --
+  DecayRate decayrate;
   DecayCounter stat_oprate;
   int stat_ops;  // ops since last heartbeat
   int stat_rd_ops;

diff --git a/src/osd/ReplicatedPG.cc b/src/osd/ReplicatedPG.cc
index 6988efc79724e0a8f00ff4e31f8edff93e95aba2..c514db6b28626cdd4f9a4068f1c97f439ae19ac3 100644 (file)
--- a/src/osd/ReplicatedPG.cc
+++ b/src/osd/ReplicatedPG.cc
@@ -675,7 +675,7 @@ void ReplicatedPG::log_op_stats(const sobject_t& soid, OpContext *ctx)
        
     if (is_primary() &&
        g_conf.osd_balance_reads)
-      stat_object_temp_rd[soid].hit(now);  // hit temp.
+      stat_object_temp_rd[soid].hit(now, osd->decayrate);  // hit temp.
   } else {
     osd->logger->inc(l_osd_c_wr);
     osd->logger->inc(l_osd_c_wrb, ctx->indata.length());