Software Defined Storage (SDS) architectures offer storage services on standard high-volume servers by providing durability, availability, reliability and on-demand scale-out elasticity. To meet different application needs, various storage interfaces like block, file, object are provided, as well as higher level interfaces like streaming write-ahead-logs, and NoSQL databases. Typically, each SDS service is implemented as an independent distributed framework, often with redundant capabilities intertwined with service-specific functions within a monolithic stack. Such monolithic SDS architectures prevent the benefits of new storage media and protocol innovations from reaching the applications using SDS services. In this paper, we advocate for a decoupled architecture by redefining the boundaries of separation within SDS. We describe an instantiation of this architecture built using a popular open-source SDS, where the SDS back-end is decoupled. Evaluation results demonstrate a 99% and 35% bandwidth consumption reduction in cluster network and total network respectively, as well as up to a 35% latency reduction, in a disaggregated storage environment just via careful decoupling. We discuss the benefits of this approach in the context of containerization for agility, scaling NVMe-oF and leveraging emerging storage accelerators.

Faulty device drivers are a major source of operating system failures. We argue that the underlying cause of many driver faults is the separation of two highly-related tasks: device verification and driver development. These two tasks have a lot in common, and result in software that is conceptually and functionally similar, yet kept totally separate. The result is a particularly bad case of duplication of effort: the verification code is correct, but is discarded after the device has been manufactured; the driver code is inferior, but used in actual device operation. We claim that the two tasks, and the software they produce, can and should be unified, and this will result in drastic improvement of device-driver quality and reduction in the development cost and time to market.

We design and test a multithreaded Snort which uses flow pinning as a major optimization. The insights derived in improving Snort's performance will apply generally to any parallel networking application that uses flow pinning as an optimization.

Nearly all programmable commercial hardware solutions offered for high-speed networking systems are capable of meeting the performance and flexibility requirements of equipment vendors. However, the primary obstacle to adoption lies with the software architectures and programming environments supported by these systems. Shortcomings include use of unfamiliar languages and libraries, portability and backwards compatibility, vendor lock-in, design and development learning curve, availability of competent developers, and a small existing base of software. Another key shortcoming of previous architectures is that either they are not multi-core oriented or they expose all the hardware details, making it very hard for programmers to deal with. In this paper, we present a practical software architecture for high-speed embedded systems that is portable, easy to learn and use, multicore oriented, and efficient.

Network edge packet-processing systems, as are commonly implemented on network processor platforms, are increasingly required to support a rich set of services. These multi-service systems are also subjected to widely varying and unpredictable traffic. Current network processor systems do not simultaneously deal well with a variety of services and fluctuating workloads. For example, current methods of worst-case, static provisioning can meet performance requirements for any workload, but provisioning each service for its worst case reduces the total number of services that can be supported. Alternately, profile-driven automatic-partitioning compilers create efficient binaries for multi-service applications for specific workloads but they are sensitive to workload fluctuations.Run-time adaptation is a potential solution to this problem. With run-time adaptation, the mapping of services to system resources can be dynamically adjusted based on the workload. We have implemented an adaptive system that automatically changes the mapping of services to processors, and handles migration of services between different processor core types to match the current workload. In this paper we explain our adaptive system built on the Intel® IXP2400 network processor. We demonstrate that it outperforms multiple different profile-driven compiled solutions for most workloads and performs within 20% of the optimal compiled solution for the remaining workloads.