First things first, but not necessarily in that order.
Doctor Who

The previous chapter described how multiple threads across microengines run in parallel to achieve the desired performance. However, one well-known problem with using parallelism is synchronizing updates to shared data structures.

To understand the synchronization problem, consider an application that classifies packets into flows and meters packets belonging to the same flow using a token bucket algorithm. The application uses a separate token bucket for each flow on the network. The parameters associated with a token bucket, such as the number of tokens and update rate, are stored in a per-flow data structure. Depending on the granularity of the flow classification, the number of flows could be very large. Therefore, these per-flow data structures are typically stored in external SRAM or DRAM. Each packet-processing thread reads, modifies, and writes the parameters in the flow data structure once per packet.

Since multiple threads across microengines may be processing packets belonging to the same flow, they must synchronize any updates to the flow data structure. Each thread needs to obtain exclusive access to the data structure, read, modify, and write it back to memory. The code executed by a thread while it has exclusive access to the data structure is called a critical section. This chapter presents different techniques for implementing critical sections.