Changeset 1470 for trunk/pdns/pdns/speedtest.cc

Timestamp:

12/24/09 17:54:31 (3 years ago)

Author:

ahu

Message:

expand speedtest infrastructure

Files:

• trunk/pdns/pdns/speedtest.cc (modified) (10 diffs)

trunk/pdns/pdns/speedtest.cc

@@ -111 +111 @@
   {
       DNSRecordContent*drc = DNSRecordContent::mastermake(QType::A, 1, 
-                                                          "1.2.3.4");
+                                                          "1.2.3.4");
       delete drc;
   }
@@ -175 +175 @@
   {
     return (boost::format("%d %s records") % d_records % 
-            DNSRecordContent::NumberToType(d_type)).str();
+            DNSRecordContent::NumberToType(d_type)).str();
   }
 
@@ -185 +185 @@
       pw.startRecord("outpost.ds9a.nl", d_type);
       DNSRecordContent*drc = DNSRecordContent::mastermake(d_type, 1, 
-                                                          d_content);
+                                                          d_content);
       drc->toPacket(pw);
       delete drc;
@@ -261 +261 @@
   // nobody reads what we output, but it appears to be the magic that shuts some nameservers up
   static const char*ips[]={"198.41.0.4", "192.228.79.201", "192.33.4.12", "128.8.10.90", "192.203.230.10", "192.5.5.241", "192.112.36.4", "128.63.2.53", 
-                     "192.36.148.17","192.58.128.30", "193.0.14.129", "198.32.64.12", "202.12.27.33"};
+                     "192.36.148.17","192.58.128.30", "193.0.14.129", "198.32.64.12", "202.12.27.33"};
   static char templ[40];
   strncpy(templ,"a.root-servers.net", sizeof(templ) - 1);
@@ -332 +332 @@
 };
 
+struct StackMallocTest
+{
+  string getName() const
+  {
+    return "stack allocation";
+  }
+
+  void operator()() const
+  {
+    char *buffer= new char[200000];
+    delete buffer;
+  }
+
+};
+
+
 struct EmptyQueryTest
 {
@@ -359 +375 @@
 
 };
+
+struct TCacheComp
+{
+  bool operator()(const pair<string, QType>& a, const pair<string, QType>& b) const
+  {
+    int cmp=strcasecmp(a.first.c_str(), b.first.c_str());
+    if(cmp < 0)
+      return true;
+    if(cmp > 0)
+      return false;
+
+    return a.second < b.second;
+  }
+};
+
+struct NegCacheEntry
+{
+  string d_name;
+  QType d_qtype;
+  string d_qname;
+  uint32_t d_ttd;
+};
+
+struct timeval d_now;
+
+static bool magicAddrMatch(const QType& query, const QType& answer)
+{
+  if(query.getCode() != QType::ADDR)
+    return false;
+  return answer.getCode() == QType::A || answer.getCode() == QType::AAAA;
+}
+
+
+bool moreSpecificThan(const string& a, const string &b)
+{
+  static string dot(".");
+  int counta=(a!=dot), countb=(b!=dot);
+  
+  for(string::size_type n=0;n<a.size();++n)
+    if(a[n]=='.')
+      counta++;
+  for(string::size_type n=0;n<b.size();++n)
+    if(b[n]=='.')
+      countb++;
+  return counta>countb;
+}
 
 
@@ -375 +437 @@
   {
     MOADNSParser mdp((const char*)&*d_packet.begin(), d_packet.size());
+    typedef map<pair<string, QType>, set<DNSResourceRecord>, TCacheComp > tcache_t;
+    tcache_t tcache;
+    
+    struct {
+            vector<DNSResourceRecord> d_result;
+            bool d_aabit;
+            int d_rcode;
+    } lwr;
+    DNSResourceRecord rr;
+    for(MOADNSParser::answers_t::const_iterator i=mdp.d_answers.begin(); i!=mdp.d_answers.end(); ++i) {          
+      DNSResourceRecord rr;
+      rr.qtype=i->first.d_type;
+      rr.qname=i->first.d_label;
+    
+      rr.ttl=i->first.d_ttl;
+      rr.content=i->first.d_content->getZoneRepresentation();  // this should be the serialised form
+      rr.d_place=(DNSResourceRecord::Place) i->first.d_place;
+      lwr.d_result.push_back(rr);
+    }
+
+    
+    
+
+      // reap all answers from this packet that are acceptable
+      for(vector<DNSResourceRecord>::iterator i=lwr.d_result.begin();i != lwr.d_result.end();++i) {
+        if(i->qtype.getCode() == QType::OPT) {
+          // <<prefix<<qname<<": skipping OPT answer '"<<i->qname<<"' from '"<<auth<<"' nameservers" <<endl;
+          continue;
+        }
+        // LOG<<prefix<<qname<<": accept answer '"<<i->qname<<"|"<<i->qtype.getName()<<"|"<<i->content<<"' from '"<<auth<<"' nameservers? ";
+        if(i->qtype.getCode()==QType::ANY) {
+          // LOG<<"NO! - we don't accept 'ANY' data"<<endl;
+          continue;
+        }
+        string auth(".");
+        if(dottedEndsOn(i->qname, auth)) {
+          if(lwr.d_aabit && lwr.d_rcode==RCode::NoError && i->d_place==DNSResourceRecord::ANSWER && 0) {
+            // LOG<<"NO! Is from delegation-only zone"<<endl;
+            // s_nodelegated++;
+            return; // RCode::NXDomain;
+          }
+          else {
+            // LOG<<"YES!"<<endl;
+
+          //  i->ttl=min(s_maxcachettl, i->ttl);
+            
+            DNSResourceRecord rr=*i;
+            rr.d_place=DNSResourceRecord::ANSWER;
+
+            // rr.ttl += d_now.tv_sec;
+
+            if(rr.qtype.getCode() == QType::NS) // people fiddle with the case
+              rr.content=toLower(rr.content); // this must stay! (the cache can't be case-insensitive on the RHS of records)
+            tcache[make_pair(i->qname,i->qtype)].insert(rr);
+          }
+        }         
+        else
+          ; // LOG<<"NO!"<<endl;
+      }
+    
+      // supplant
+      for(tcache_t::iterator i=tcache.begin();i!=tcache.end();++i) {
+        if(i->second.size() > 1) {  // need to group the ttl to be the minimum of the RRSET (RFC 2181, 5.2)
+          uint32_t lowestTTL=numeric_limits<uint32_t>::max();
+          for(tcache_t::value_type::second_type::iterator j=i->second.begin(); j != i->second.end(); ++j)
+            lowestTTL=min(lowestTTL, j->ttl);
+          
+          for(tcache_t::value_type::second_type::iterator j=i->second.begin(); j != i->second.end(); ++j)
+            ((tcache_t::value_type::second_type::value_type*)&(*j))->ttl=lowestTTL;
+        }
+
+        // RC.replace(d_now.tv_sec, i->first.first, i->first.second, i->second, lwr.d_aabit);
+      }
+      set<string, CIStringCompare> nsset;  
+      // LOG<<prefix<<qname<<": determining status after receiving this packet"<<endl;
+
+      bool done=false, realreferral=false, negindic=false;
+      string newauth, soaname, newtarget;
+      string qname(".");
+      vector<DNSResourceRecord> ret;
+      QType qtype(QType::A);
+      string auth(".");
+ 
+      for(vector<DNSResourceRecord>::const_iterator i=lwr.d_result.begin();i!=lwr.d_result.end();++i) {
+        if(i->d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,i->qname) && i->qtype.getCode()==QType::SOA && 
+           lwr.d_rcode==RCode::NXDomain) {
+          // LOG<<prefix<<qname<<": got negative caching indication for RECORD '"<<qname+"'"<<endl;
+          ret.push_back(*i);
+
+          NegCacheEntry ne;
+
+          ne.d_qname=i->qname;
+          ne.d_ttd=d_now.tv_sec + min(i->ttl, 3600U); // controversial
+          ne.d_name=qname;
+          ne.d_qtype=QType(0); // this encodes 'whole record'
+          
+          {
+            // Lock l(&s_negcachelock);
+            // replacing_insert(s_negcache, ne);
+          }
+          negindic=true;
+        }
+        else if(i->d_place==DNSResourceRecord::ANSWER && iequals(i->qname, qname) && i->qtype.getCode()==QType::CNAME && (!(qtype==QType(QType::CNAME)))) {
+          ret.push_back(*i);
+          newtarget=i->content;
+        }
+        // for ANY answers we *must* have an authoritive answer
+        else if(i->d_place==DNSResourceRecord::ANSWER && pdns_iequals(i->qname, qname) && 
+                (
+                 i->qtype==qtype || (lwr.d_aabit && (qtype==QType(QType::ANY) || magicAddrMatch(qtype, i->qtype) ) )
+                ) 
+               )   
+          {
+          
+          // LOG<<prefix<<qname<<": answer is in: resolved to '"<< i->content<<"|"<<i->qtype.getName()<<"'"<<endl;
+
+          done=true;
+          ret.push_back(*i);
+        }
+        else if(i->d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,i->qname) && i->qtype.getCode()==QType::NS) { 
+          if(moreSpecificThan(i->qname,auth)) {
+            newauth=i->qname;
+            // LOG<<prefix<<qname<<": got NS record '"<<i->qname<<"' -> '"<<i->content<<"'"<<endl;
+            realreferral=true;
+          }
+          else 
+            ;// // LOG<<prefix<<qname<<": got upwards/level NS record '"<<i->qname<<"' -> '"<<i->content<<"', had '"<<auth<<"'"<<endl;
+          nsset.insert(i->content);
+        }
+        else if(!done && i->d_place==DNSResourceRecord::AUTHORITY && dottedEndsOn(qname,i->qname) && i->qtype.getCode()==QType::SOA && 
+           lwr.d_rcode==RCode::NoError) {
+          // LOG<<prefix<<qname<<": got negative caching indication for '"<< (qname+"|"+i->qtype.getName()+"'") <<endl;
+          ret.push_back(*i);
+          
+          NegCacheEntry ne;
+          ne.d_qname=i->qname;
+          ne.d_ttd=d_now.tv_sec + i->ttl;
+          ne.d_name=qname;
+          ne.d_qtype=qtype;
+          if(qtype.getCode()) {  // prevents us from blacking out a whole domain
+           // Lock l(&s_negcachelock);
+            // replacing_insert(s_negcache, ne);
+          }
+          negindic=true;
+        }
+      }
+
   }
   const vector<uint8_t>& d_packet;
   std::string d_name;
 };
+
+struct ParsePacketBareTest
+{
+  explicit ParsePacketBareTest(const vector<uint8_t>& packet, const std::string& name) 
+    : d_packet(packet), d_name(name)
+  {}
+
+  string getName() const
+  {
+    return "parse '"+d_name+"' bare";
+  }
+
+  void operator()() const
+  {
+    MOADNSParser mdp((const char*)&*d_packet.begin(), d_packet.size());
+  }
+  const vector<uint8_t>& d_packet;
+  std::string d_name;
+};
+
 
 struct SimpleCompressTest
@@ -418 +647 @@
 };
 
+
+
+struct IEqualsTest
+{
+  string getName() const
+  {
+    return "iequals test";
+  }
+
+  void operator()() const
+  {
+      static string a("www.ds9a.nl"), b("www.lwn.net");
+      bool ret = iequals(a, b);
+  }
+
+};
+
+struct MyIEqualsTest
+{
+  string getName() const
+  {
+    return "pdns_iequals test";
+  }
+
+  void operator()() const
+  {
+      static string a("www.ds9a.nl"), b("www.lwn.net");
+      bool ret = pdns_iequals(a, b);
+  }
+
+};
+
+
+struct StrcasecmpTest
+{
+  string getName() const
+  {
+    return "strcasecmp test";
+  }
+
+  void operator()() const
+  {
+      static string a("www.ds9a.nl"), b("www.lwn.net");
+      bool ret = strcasecmp(a.c_str(), b.c_str());
+  }
+};
+
+
 struct NOPTest
 {
@@ -439 +716 @@
   signal(SIGVTALRM, alarmHandler);
   
-  //  doRun(NOPTest());
+  doRun(NOPTest());
+  
+  doRun(IEqualsTest());
+  doRun(MyIEqualsTest());
+  doRun(StrcasecmpTest());
+
+  doRun(StackMallocTest());
 
   vector<uint8_t> packet = makeRootReferral();
+  doRun(ParsePacketBareTest(packet, "root-referral"));
   doRun(ParsePacketTest(packet, "root-referral"));
 
@@ -455 +739 @@
   packet = makeTypicalReferral();
   cerr<<"typical referral size: "<<packet.size()<<endl;
+  doRun(ParsePacketBareTest(packet, "typical-referral"));
+
   doRun(ParsePacketTest(packet, "typical-referral"));
 
-
   doRun(SimpleCompressTest("www.france.ds9a.nl"));
 
+  
   doRun(VectorExpandTest());