Synchronization Optimization For Network Processors

The rapid growth of internet drives the emergence of Network Processors (NPs) to satisfy both the increasing link speed and the need for flexibility. These two goals require that network processors be implemented as parallel multiprocessor systems. If detailed underlying architecture is exposed to the programmer, programming such parallel systems requires explicit resource management, allocation and coordination, which is very cumbersome and error-prone. In order to shift the focus of programmers from such details to programs themselves, high level programming models and languages hide the underlying details from the programmers and express the application in sequential semantics.That way, automatic parallelization is needed to transform the sequential program to parallelized form such that generated code can correctly run on multiple processors. When automatically parallelizing the original program for the multiprocessor systems, many low level details masked by the high level language must be managed by the compiler. Among other things, the compiler is required to make sure that necessary synchronization is introduced to preserve the sequential semantics of the original program. From the perspective of networking applications, variables that need synchronization are usually internal states of the application that are shared among processing different packets. On the other hand, networking systems are becoming stateful, especially for fourth or above layers in the network stack. One example is the session states of many high layer protocols. In these applications, more variables are shared and more dependencies are involved. As a result, compilers are faced with generating very complex synchronization to protect a large amount of internal states of these applications.In order to optimize synchronization, we studied the automatic parallelizing compiler for Intel IXP auto-partitioning C programming model, and proposed a novel framework of compiler transformation. In this framework, we use a program partitioning approach to tackle the problems and issues on synchronizing different threads. Experiments demonstrated a good performance result and showed that our approach achieved considerable improvement in program parallelism.