anchor.diff:  the type of work that they can handle. These will be discussed in greater
   detail later.
   
  -=== Event ===
  +=== Event
   Events are what threads process to perform their work. Events can represent
   new work, such as the arrival of a packet that needs to be processed, or they
   can represent the completion of requests that have executed asynchronously.
  
positive.code: 
  Pools are represented by handles of abstract type +odp_pool_t+.
  
  === Shared Memory ===
  Shared memory represents raw blocks of storage that are sharable between
  threads. They are the building blocks of pools but can be used directly by
  ODP applications if desired.
  
  Shared memory is represented by handles of abstract type +odp_shm_t+.
  
  === Buffer ===
  A buffer is a fixed sized block of shared storage that is used by ODP
  components and/or applications to realize their function. Buffers contain
  zero or more bytes of application data as well as system maintained
  metadata that provide information about the buffer, such as its size or the
  pool it was allocated from. Metadata is an important ODP concept because it
  allows for arbitrary amounts of side information to be associated with an
  ODP object. Most ODP objects have assocaited metadata and this metadata is
  manipulated via accessor functions that act as getters and setters for
  this information. Getter acces functions permit an application to read
  a metadata item, while setter access functions permit an application to write
  a metadata item. Note that some metadata is inherently read only and thus
  no setter is provided to manipulate it.  When object have multiple metadata
  items, each has its own associated getter and/or setter access function to
  inspect or manipulate it.
  
  Buffers are represened by handles of abstract type +odp_buffer_t+.
  
  === Packet ===
  Packets are received and transmitted via I/O interfaces and represent
  the basic data that data plane applications manipulate.
  Packets are drawn from pools of type +ODP_POOL_PACKET+.
  
negative.code: by ODP application programmers, as well as implementers, to understand the
  precise syntax and semantics of each API.
  
  == ODP API Concepts
  ODP programs are built around several conceptual structures that every
  application programmer needs to be familiar with to use ODP effectively. The
  main ODP concepts are:
  Thread, Event, Queue, Pool, Shared Memory, Buffer, Packet, PktIO, Timer,
  and Synchronizer.
  
  === Thread
  The thread is the fundamental programming unit in ODP.  ODP applications are
  organized into a collection of threads that perform the work that the
  application is designed to do. ODP threads may or may not share memory with
  