NFD

The maximum Interest lifetime:

• chasing & state initial states: 3000 ms (https://github.com/remap/ndnrtc/blob/master/cpp/src/pipeliner.cpp#L302)
• other states: whatever is set in configuration - default is 2000ms (https://github.com/remap/ndnrtc/blob/master/cpp/src/pipeliner.cpp#L310)

I have taken the coredump on REMAP node, so we can analyze the memory and see what specific entries are in memory. To do actual analysis, we need somebody to write gdb scripts to print out memory structures in readable form.

Relevant resources for that: http://stackoverflow.com/questions/14698086/gdb-python-scripting-any-samples-iterating-through-c-c-struct-fields and http://docs.adacore.com/gdb-docs/html/gdb_24.html.

On a separate note. I am curios not about minimal lifetime size, but rather maximum lifetime size set in NDN-RTC interests. This is an artifact of the current protocol definition and implementation, but if lifetime is set too long, the PIT entry can legitimately persist in NFD for a long period of time.

Another separate note. The excessive number of entries seem to be only with REMAP hub. UCLA, Arizona, and Memphis hubs (were part of ndnrtc test) have small numbers of PIT and NameTree entries.

Junxiao believes may be related to #3219. Alex looked at memory dump from REMAP node and says (typical?) interest lifetime is 2 sec.

For other components of NdnCon mentioned by Junxiao: we also uses ChronoSync from ndn-cpp, and a discovery for conferences, users, and chatrooms.

The interests sent by these components should have 5s maximum lifetime. (Most of those interests have 2s lifetime, as mentioned by Alex).

A few other places that set the interest lifetime in the application code:
Sync interest
Sync interest timeout
Sync interest update
Entity discovery interest
Entity discovery heartbeat interest

And default lifetime configuration.

And a few occurrences such as this in ChronoSync2013 in ndn-cpp.

Please note that the occasional "/local/timeout" interest in the code is used as a timer in ndn-cpp, and is not propagated to nfd.

The maximum lifetime for the Interest is 3 seconds in NDN-RTC.

ndncon also uses ConferenceDiscovery library for chat and user discovery, as well as for chat messaging. I don't think it uses Interests with lifetimes larger than 5 sec. @Zhehao can confirm on this.

I can confirm, for a few records I looked, in and out records are empty

(gdb) print (*$tree.m_buckets[1131].m_entry.get().m_pitEntries[0].get())
$14 = {
  <nfd::StrategyInfoHost> = {
    m_items = std::map with 0 elements
  },
  <boost::noncopyable_::noncopyable> = {<No data fields>},
  members of nfd::pit::Entry:
  m_unsatisfyTimer = std::shared_ptr<ndn::util::scheduler::EventIdImpl> (empty) to 0x0,
  m_stragglerTimer = std::shared_ptr<ndn::util::scheduler::EventIdImpl> (empty) to 0x0,
  m_interest = std::shared_ptr<const ndn::Interest> (usecount 1, weakcount 1) to 0x1607d1d0 = {
    Use count = 1,
    Weak count = 1,
    Managed value = 0x1607d1d0
  },
  m_inRecords = empty std::list,
  m_outRecords = empty std::list,
  static LOCALHOST_NAME = {
    <std::enable_shared_from_this<ndn::Name>> = {
      _M_weak_this = std::weak_ptr<ndn::Name> (empty) to 0x0
    },
    members of ndn::Name:
    static npos = 18446744073709551615,
    m_nameBlock = {
      m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
      m_type = 7,
      m_begin = <error reading variable>
  },
  static LOCALHOP_NAME = {
    <std::enable_shared_from_this<ndn::Name>> = {
      _M_weak_this = std::weak_ptr<ndn::Name> (empty) to 0x0
    },
    members of ndn::Name:
    static npos = 18446744073709551615,
    m_nameBlock = {
      m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
      m_type = 7,
      m_begin = <error reading variable>
  },
  m_nameTreeEntry = std::shared_ptr<nfd::name_tree::Entry> (usecount 3, weakcount 1) to 0x9a6cd40 = {
    Use count = 3,
    Weak count = 1,
    Managed value = 0x9a6cd40
  }
}

For reference, the recorded interests

$2 = {
  <ndn::TagHost> = {
    m_tags = std::map with 1 elements = {
      [10] = std::shared_ptr<ndn::Tag> (usecount 1, weakcount 0) to 0x151e6670 = {
        Use count = 1,
        Weak count = 0,
        Managed value = 0x151e6670
      }
    }
  },
  <std::enable_shared_from_this<ndn::Interest>> = {
    _M_weak_this = std::weak_ptr<ndn::Interest> (usecount 1, weakcount 1) to 0x1607d1d0 = {
      Use count = 1,
      Weak count = 1,
      Managed value = 0x1607d1d0
    }
  },
  members of ndn::Interest:
  m_name = "/ndn/edu/ucla/remap/ndnrtc/user/test/streams/camera/hi/delta/135017/data/%00%06",
  m_selectors = {
    m_minSuffixComponents = -1,
    m_maxSuffixComponents = -1,
    m_publisherPublicKeyLocator = {
      m_type = ndn::KeyLocator::KeyLocator_None,
      m_name = ,
      m_keyDigest = {
        m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
        m_type = 4294967295,
        m_begin = <error reading variable>,
      m_wire = {
        m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
        m_type = 4294967295,
        m_begin = <error reading variable>
    },
    m_exclude = {
      m_exclude = std::map with 0 elements,
      m_wire = {
        m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
        m_type = 4294967295,
        m_begin = <error reading variable>
    },
    m_childSelector = -1,
    m_mustBeFresh = true,
    m_wire = {
      m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
        Use count = 23,
        Weak count = 0,
        Managed value = 0x1b3beb80
      },
      m_type = 9,
      m_begin = 9 '\t',
      m_end = 10 '\n',
      m_size = 4,
      m_value_begin = 18 '\022',
      m_value_end = 10 '\n',
      m_subBlocks = std::vector of length 1, capacity 1 = {{
          m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
            Use count = 23,
            Weak count = 0,
            Managed value = 0x1b3beb80
          },
          m_type = 18,
          m_begin = 18 '\022',
          m_end = 10 '\n',
          m_size = 2,
          m_value_begin = 10 '\n',
          m_value_end = 10 '\n',
          m_subBlocks = std::vector of length 0, capacity 0
        }}
    }
  },
  m_nonce = {
    m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
      Use count = 23,
      Weak count = 0,
      Managed value = 0x1b3beb80
    },
    m_type = 10,
    m_begin = 10 '\n',
    m_end = 12 '\f',
    m_size = 6,
    m_value_begin = 31 '\037',
    m_value_end = 12 '\f',
    m_subBlocks = std::vector of length 0, capacity 0
  },
  m_interestLifetime = {
    rep_ = 2000
  },
  m_link = {
    m_buffer = std::shared_ptr<const ndn::Buffer> (empty) to 0x0,
    m_type = 4294967295,
    m_begin = <error reading variable>,
  m_linkCached = std::shared_ptr<ndn::Link> (empty) to 0x0,
  m_selectedDelegationIndex = 18446744073709551615,
  m_wire = {
    m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
      Use count = 23,
      Weak count = 0,
      Managed value = 0x1b3beb80
    },
    m_type = 5,
    m_begin = 5 '\005',
    m_end = 8 '\b',
    m_size = 107,
    m_value_begin = 7 '\a',
    m_value_end = 8 '\b',
    m_subBlocks = std::vector of length 4, capacity 4 = {{
        m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
          Use count = 23,
          Weak count = 0,
          Managed value = 0x1b3beb80
        },
        m_type = 7,
        m_begin = 7 '\a',
        m_end = 9 '\t',
        m_size = 91,
        m_value_begin = 8 '\b',
        m_value_end = 9 '\t',
        m_subBlocks = std::vector of length 0, capacity 0
      }, {
        m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
          Use count = 23,
          Weak count = 0,
          Managed value = 0x1b3beb80
        },
        m_type = 9,
        m_begin = 9 '\t',
        m_end = 10 '\n',
        m_size = 4,
        m_value_begin = 18 '\022',
        m_value_end = 10 '\n',
        m_subBlocks = std::vector of length 0, capacity 0
      }, {
        m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
          Use count = 23,
          Weak count = 0,
          Managed value = 0x1b3beb80
        },
        m_type = 10,
        m_begin = 10 '\n',
        m_end = 12 '\f',
        m_size = 6,
        m_value_begin = 31 '\037',
        m_value_end = 12 '\f',
        m_subBlocks = std::vector of length 0, capacity 0
      }, {
        m_buffer = std::shared_ptr<const ndn::Buffer> (usecount 23, weakcount 0) to 0x1b3beb80 = {
          Use count = 23,
          Weak count = 0,
          Managed value = 0x1b3beb80
        },
        m_type = 12,
        m_begin = 12 '\f',
        m_end = 8 '\b',
        m_size = 4,
        m_value_begin = 7 '\a',
        m_value_end = 8 '\b',
        m_subBlocks = std::vector of length 0, capacity 0
      }}
  }
}

The logic looks good to me.