Abstract:
One embodiment of the present invention provides a system for performing concurrent hashing of packet streams. During operation, the system receives a stream of packets at a controller. The controller then identifies types and parameters for a plurality of different hashing operations based on a received packet. The controller further sends the packet concurrently to corresponding different hashing modules to produce different hash values, which can be used to facilitate packet forwarding.

Description:
RELATED APPLICATIONS 
     The subject matter of this application is related to the subject matter in the following U.S. Pat. Nos. 8,243,735, 8,160,069, and 8,204,060, the disclosures of which herein are incorporated by reference in their entirety. 
     BACKGROUND 
     1. Field 
     The present disclosure relates generally to facilitating data processing in network. More specifically, the present disclosure relates to a system and method for facilitating direct concurrent hashes and sub-hashes in data streams. 
     2. Related Art 
     The proliferation of the Internet and e-commerce continues to fuel revolutionary changes in the network industry. Today, a significant number of information exchanges, from online movie viewing to daily news delivery, retail sales, and instant messaging, are conducted online. An increasing number of Internet applications are also becoming mobile. However, the current Internet operates on a largely location-based addressing scheme. The two most ubiquitous protocols, the Internet Protocol (IP) and Ethernet protocol, are both based on location-based addresses. That is, a consumer of content can only receive the content by explicitly requesting the content from an address (e.g., IP address or Ethernet media access control (MAC) address) closely associated with a physical object or location. This restrictive addressing scheme is becoming progressively more inadequate for meeting the ever-changing network demands. 
     Recently, content-centric network (CCN) architectures have been proposed in the industry. CCN brings a new approach to content transport. Instead of having network traffic viewed at the application level as end-to-end conversations over which content travels, content is requested or returned based on its unique name, and the network is responsible for routing content from the provider to the consumer. Note that content includes data that can be transported in the communication system, including any form of data such as text, images, video, and/or audio. A consumer and a provider can be a person at a computer or an automated process inside or outside the CCN. A piece of content can refer to the entire content or a respective portion of the content. For example, a newspaper article might be represented by multiple pieces of content embodied as data packets. A piece of content can also be associated with metadata describing or augmenting the piece of content with information such as authentication data, creation date, content owner, etc. 
     In CCN, content objects and interests are identified by their names, which is typically a hierarchically structured variable-length identifier (HSVLI). Some networking systems may require multiple hashes over the same data stream to process the packets. These hashes may be of different types, and some hashes may require transferring state from previous hashes. Efficient processing of CCN packets while producing multiple hashes for a data stream remains to be a challenge. 
     SUMMARY 
     One embodiment of the present invention provides a system for performing concurrent hashing of packet streams. During operation, the system receives a stream of packets at a controller. The controller then identifies types and parameters for a plurality of different hashing operations based on a received packet. The controller further sends the packet concurrently to corresponding different hashing modules to produce different hash values, which can be used to facilitate packet forwarding. 
     In a variation on this embodiment, a first of the plurality of hashing operation uses as input an intermediate state of a second hashing operation. 
     In a further variation, the first and second hashing operations are SipHash operations. 
     In a variation on this embodiment, the plurality of different hashing operations include one or more of: a SHA-2 hash or truncation; a SHA-3 hash or truncation; a SipHash; and a Flower-Noll-Vo (FNV) hash of varying size. 
     In a variation on this embodiment, the controller receives status from different hashing operations and schedules hashing operations in a next cycle based on the received status for different hashing operations. 
     In a variation on this embodiment, the system receives multiple packet streams in parallel into a plurality of corresponding controllers and cross-connects a respective packet stream to an array of hashing modules, thereby facilitating concurrent multiple hashing operations for each of the multiple packet streams. 
     In a further variation, when a hashing operation returns a status that indicates error or fault, the system discontinues using the corresponding hashing module. 
    
    
     
       BRIEF DESCRIPTION OF THE FIGURES 
         FIG. 1  illustrates an exemplary architecture of a network, in accordance with an embodiment of the present invention. 
         FIG. 2  illustrates concurrent hashes over a CCN content object packet, in accordance with one embodiment of the present invention. 
         FIG. 3  illustrates concurrent hashes over a CCN content object packet, in accordance with one embodiment of the present invention. 
         FIG. 4  illustrates exemplary downstream processing of the output from a hash processor, in accordance with one embodiment of the present invention. 
         FIG. 5  illustrates an exemplary hash processor, in accordance with an embodiment of the present invention. 
         FIG. 6  illustrates such a hash array, in accordance with one embodiment of the present invention. 
         FIGS. 7A, 7B, and 7C  illustrate exemplary first, second, and third stages of packet hash processing, respectively, in accordance with one embodiment of the present invention. 
         FIG. 8  illustrates an exemplary system that facilitates parallel processing of multiple input packet queues, in accordance with one embodiment of the present invention. 
     
    
    
     DETAILED DESCRIPTION 
     Embodiments of the present invention provide a system and method for facilitating concurrent production of hashes for CCN data packets. 
     During operation, when a CCN-enabled switch or router receives a content object or fragments of the content object, the switch determines that the content object should be cached, and sends a copy of the content object (or its fragments) to a content store manager. The content store manager reassembles the fragments (when needed), and writes the copy of the content object into the attached storage. More specifically, before writing into the attached storage, the content store manager may also fragment the content object to suitable size for transportation. Each transported fragment is written into a contiguous set of blocks in the attached storage, and the content store manager adds transport and fragment headers to each contiguous set of blocks. In addition, the content store manager generates and populates a cache table indexed by the name prefix of the content object. An entry in the cache table specifies locations of the sets of storage blocks at which fragments of the content object are located. In some embodiments, a cache entry includes a set of pre-assembled data communication frames with each frame dedicated to a fragment. A pre-assembled frame may include appropriate transport headers and a pointer to the storage blocks, and can be used to retrieve the corresponding fragment from the attached storage. 
     In general, CCN uses two types of messages: Interests and Content Objects. An Interest carries the hierarchically structured variable-length identifier (HSVLI), also called the “name,” of a Content Object and serves as a request for that object. If a network element (e.g., router) receives multiple interests for the same name, it may aggregate those interests. A network element along the path of the Interest with a matching Content Object may cache and return that object, satisfying the Interest. The Content Object follows the reverse path of the Interest to the origin(s) of the Interest. A Content Object contains, among other information, the same HSVLI, the object&#39;s payload, and cryptographic information used to bind the HSVLI to the payload. 
     The terms used in the present disclosure are generally defined as follows (but their interpretation is not limited to such):
         “HSVLI:” Hierarchically structured variable-length identifier, also called a Name. It is an ordered list of Name Components, which may be variable length octet strings. In human-readable form, it can be represented in a format such as ccnx:/path/part. There is not a host or query string. As mentioned above, HSVLIs refer to content, and it is desirable that they be able to represent organizational structures for content and be at least partially meaningful to humans. An individual component of an HSVLI may have an arbitrary length. Furthermore, HSVLIs can have explicitly delimited components, can include any sequence of bytes, and are not limited to human-readable characters. A longest-prefix-match lookup is important in forwarding packets with HSVLIs. For example, an HSVLI indicating an interest in “/parc/home/bob” will match both “/parc/home/bob/test.txt” and “/parc/home/bob/bar.txt.” The longest match, in terms of the number of name components, is considered the best because it is the most specific.   “Interest:” A request for a Content Object. The Interest specifies an HSVLI name prefix and other optional selectors that can be used to choose among multiple objects with the same name prefix. Any Content Object whose name matches the Interest name prefix and selectors satisfies the Interest.   “Content Object:” A data object sent in response to an Interest. It has an HSVLI name and a Contents payload that are bound together via a cryptographic signature. Optionally, all Content Objects have an implicit terminal name component made up of the SHA-256 digest of the Content Object. In one embodiment, the implicit digest is not transferred on the wire, but is computed at each hop, if needed.       

     As mentioned before, an HSVLI indicates a piece of content, is hierarchically structured, and includes contiguous components ordered from a most general level to a most specific level. The length of a respective HSVLI is not fixed. In content-centric networks, unlike a conventional IP network, a packet may be identified by an HSVLI. For example, “abcd/bob/papers/ccn/news” could be the name of the content and identifies the corresponding packet(s), i.e., the “news” article from the “ccn” collection of papers for a user named “Bob” at the organization named “ABCD.” To request a piece of content, a node expresses (e.g., broadcasts) an interest in that content by the content&#39;s name. An interest in a piece of content can be a query for the content according to the content&#39;s name or identifier. The content, if available in the network, is routed back to it from any node that stores the content. The routing infrastructure intelligently propagates the interest to the prospective nodes that are likely to have the information and then carries available content back along the path which the interest traversed. 
       FIG. 1  illustrates an exemplary architecture of a network, in accordance with an embodiment of the present invention. In this example, a network  180  comprises nodes  100 - 145 . Each node in the network is coupled to one or more other nodes. Network connection  185  is an example of such a connection. The network connection is shown as a solid line, but each line could also represent sub-networks or super-networks, which can couple one node to another node. Network  180  can be content-centric, a local network, a super-network, or a sub-network. Each of these networks can be interconnected so that a node in one network can reach a node in other networks. The network connection can be broadband, wireless, telephonic, satellite, or any type of network connection. A node can be a computer system, an end-point representing users, and/or a device that can generate interest or originate content. 
     In accordance with an embodiment of the present invention, a consumer can generate an Interest in a piece of content and then send that Interest to a node in network  180 . The piece of content can be stored at a node in network  180  by a publisher or content provider, who can be located inside or outside the network. For example, in  FIG. 1 , the Interest in a piece of content originates at node  105 . If the content is not available at the node, the Interest flows to one or more nodes coupled to the first node. For example, in  FIG. 1 , the Interest flows (interest flow  150 ) to node  115 , which does not have the content available. Next, the Interest flows (interest flow  155 ) from node  115  to node  125 , which again does not have the content. The Interest then flows (interest flow  160 ) to node  130 , which does have the content available. The flow of the content then retraces its path in reverse (content flows  165 ,  170 , and  175 ) until it reaches node  105 , where the content is delivered. Other processes such as authentication can be involved in the flow of content. 
     In network  180 , any number of intermediate nodes (nodes  100 - 145 ) in the path between a content holder (node  130 ) and the Interest generation node (node  105 ) can participate in caching local copies of the content as it travels across the network. Caching reduces the network load for a second subscriber located in proximity to other subscribers by implicitly sharing access to the locally cached content. 
     Typically, CCN networking systems may require several hashes over the same data stream to process and forward CCN packets. These hashes may be of different types, and some hashes may require transferring state from previous hashes. For example, a Content Object packet may need to SHA-256 hash over the entire message. It may also need other hashes, such as SipHash or Fowler-Noll-Vo (FNV) hash over embedded byte arrays, such as the CCN name path segments or components. 
       FIG. 2  illustrates concurrent hashes over a CCN content object packet, in accordance with one embodiment of the present invention. In this example, a CCN packet  200  includes headers (both in front of and at the tail of the packet) which are not hashed (marked as “skip”). A long SHA-256 hash is computed over the entire message body  202 , excluding the tail. Embedded within the message is another data structure, namely the CCN Name, which typically needs several continuing hashes computed by a CCN switch. In one embodiment, the first name component is hashed, then the second name component&#39;s hash depends on the first name component too, and so on, through the entire name, which results in an array of SipHash  206  (which implies that in this example SipHash is computed for the name components). The name hash (i.e., array of SipHash  206 ) is used for forwarding table lookups (e.g., for performing longest match lookups), so it does not need to be a cryptographic hash. 
     Future protocols or features may require different hashes. Therefore, the hash processor can include a flexible ruleset so the control unit can determine an appropriate set of hashes to use from the available hasher. The ruleset maps packets, based on protocol headers, to a set of rules to compute offsets within the packet, thereby allowing the hasher to take correct input from the packet data to compute hashes. The control unit can also include an arithmetic unit (ALU) and a packet schema processor, such as a type-length-value (TLV) engine or other rule based engine. 
     For example,  FIG. 3  shows a packet  300  that requires a SHA-3 512-bit hash of the message body  302 , and a SHA-3 256-bit hash of the payload  305 , in addition to the continuing name hashes (i.e., array of FNV-1a hases  306 ). Note that in this example, FNV-1a is used for hashing the name components. 
       FIG. 4  illustrates exemplary downstream processing of the output from a hash processor, in accordance with one embodiment of the present invention. In this example, a hash processor  400  includes a number of arrival (input) queues, such as arrival queue  402 , a hash array  404 , and a number of hash output queues, such as hash output queue  406 . The arriving packets are replicated and placed in the various arrival queues, which feed to different portions of hash array  404  to produce different hash values. The output from the hash output queues are then coupled to a control module  408 , which dispatches respective data and hashes to CCN-specific hardware, such as a fast pending interest table (PIT) lookup module  422  and a forwarding information base (FIB) lookup module  424 . Some hashes may be transitory and not saved, while others, like the SHA-256 content object hash, may be saved in a context memory  428 . In addition, frame memory  426  can optionally save the data packet for future use. 
     The following describes a hardware and software system for such a flexible hash processing unit capable of concurrent multiple hashes on the same data stream. 
     In one embodiment, the hash processor in hardware uses inter-chip lanes, such as XAUI, Interlaken, or PCIe to communicate with the upstream (i.e. media ports) and downstream (i.e. network processor or CPU). It could also have native media ports. As illustrated in  FIG. 5 , a hash processor  502  takes in packets, then applies a set of matching rules to determine what type of hashes to compute for a given packet based on its header and internal structure. The output is the original packets plus the computed hashes. 
     For example, the output stream could be the original packet followed by a special packet with an identifier to inform the next stage in the processing pipe, such as a network processing unit (NPU), that it contains hashes associated with the previous packet. The hash packet could include a table of contents to allow the NPU to easily lookup specific hashes within the packet. 
     Within the hash processor is an array of hashers with output buffers. The hasher could be of various types, such as SHA-256, SipHash, or FNV-1a 128-bit, or programmable, such as any SHA-2 or SHA-3 variant. Because hashes will become available at different times, based on their location within the packet, each hasher has an output buffer to hold results until the control unit determines it can write them to the hash output queue. The original data packet is also copied to the data output queue via a pass-through.  FIG. 6  illustrates such a hash array, in accordance with one embodiment of the present invention. Incoming packets are first replicated and dispatched by the control module. The packets are then fed into different hashers, the output of which is buffered. The packet is also placed in a data output queue via a pass-through data path. 
     In this description, we break the hash processing into status cycles and processing cycles, which may be considered as corresponding to pipeline stages for illustration purposes. Actual implementations may have a finer pipeline than shown and may work on larger or smaller data blocks than the exemplary 64-byte blocks. 
     Hashers also have the ability to initialize their state based on another hasher&#39;s intermediate results. For example, a first name component could begin at byte offset  28  and end at byte offset  37 . The hasher would likely pad the input to byte  40  (for 8-byte alignment) with Os or other hash-specific patterns. The next name component begins at byte offset  38 . To chain the hashes, the second hasher would take the intermediate state from the first hasher at byte offset  32 , which is the last full block before the first hasher begins to pad. The second hasher would then continue through the end of the second name component. 
       FIG. 7A  shows an exemplary first stage of packet hash processing, in accordance with one embodiment of the present invention. The controller puts bytes B 0 , B 1 , . . . , B 63  on the data bus and sends commands to each of the hashers (or at least those without a no-operation NOP). The controller instructs a SHA-256 processor to begin hashing the data bus at byte offset  20 . There is no end specified, so the SHA-256 hasher will continue through the end of the block. The controller also instructs hasher Unit # 1  that it should begin its SipHash at byte offset  24  and end at byte offset  60 . The controller instructs hasher Unit # 2  to begin its SipHash at byte offset  56 . This is because hasher Unit # 2  is a continuation to hasher Unit # 1 . The controller instructs Unit # 2  to transfer the intermediate state from Unit # 1  at the end of byte  55 , then begin its hash at byte offset  56 . Note that the controller specifies byte  56  instead of the actual beginning of the second name component at byte  61  because SipHash is an 8-byte aligned hash and Unit # 1  would begin padding the input after byte  60 . 
       FIG. 7B  illustrates an exemplary second stage of packet hash processing, in accordance with one embodiment of the present invention. In this second processing cycle, the controller reads the status of each hasher. Unit # 0  reports “OK” because it is in the middle of doing a SHA-256 hash and there are no errors. Unit # 1  reports “BUSY” because it is still calculating the end-of-message padding for its SipHash that ended on byte  60  and writing the result to the buffer. Unit # 2  reports “OK” because it is in the middle of doing its SipHash and there are no errors. Unit # 3  reports “IDLE” because it is available for new work. 
       FIG. 7C  illustrates an exemplary third stage of packet hash processing, in accordance with one embodiment of the present invention. In this third processing cycle, the controller puts bytes B 64 , . . . , B 127  on the data bus and makes new task assignments for each hasher. The controller instructs Unit # 0  to continue its SHA-256 hash over the entire block. The controller also sends a no-op instruction to Unit # 1  because that unit had reported “BUSY”. The controller instructs Unit # 2  to continue its hashing and end at byte  68 . Hasher Unit # 2  will then pad the hash and write the result to its buffer. Furthermore, the controller instructs Unit # 3  to begin hashing at byte  64 , reading the intermediate state from Unit # 2  after byte  63 . The controller tells Unit # 3  to begin at byte  64 , because that is the last full 8-byte aligned word Unit # 3  can read as an intermediate result from Unit # 2 . Later cycles continue with the controller reading hasher status, then placing new data blocks on the bus and issuing command to each hasher. 
     In a practical system, there may be many parallel packet arrivals. For example, a router line card could have multiple media interfaces linked to the hash processor over many Interlaken lanes or XAUI interfaces. Each packet arrival queue has its own controller managing the state of the parsing. A cross-connect mediates the controllers to the available hasher resources. An example would be a cross-bar switch. Once a controller begins using a hasher (i.e., a hasher array), it stays with that hasher until the current operation finishes. An output cross-connect links the hasher buffers to the output lanes for packet data and hasher data. Note that if a hasher fails or experiences errors or fault, the cross connect can select a different hasher to ensure error-free operation. 
     The cross-connect arbiter should consider packet priority in assigning resources. It should also avoid deadlock between controllers. For example, a controller may need to give the cross-connect an estimate of the needed resources before beginning so the controller can avoid deadlock. Some systems could be designed—based on worst case timing—of known packet formats to ensure there are always sufficient resources. The cross-connect, if it deadlocks, could void a lower priority session and re-queue that data stream from the output buffers to the input buffers. 
       FIG. 8  illustrates an exemplary system that facilitates parallel processing of multiple input packet queues, in accordance with one embodiment of the present invention. In this example, a cross connect  802  connects multiple packet arrival queues to different hash processors, and a second cross connect  804  connects the hash results to different hash output queues. Specifically, there are three packet input queues. There could be more or fewer input lanes with a packet scheduler between the input lanes and the service queues. Cross connect  802  assigns each controller to hasher resources. Output cross connect  804  schedules hasher buffers to output queues for processing by the next unit. 
     In summary, this disclosure describes an architecture and system for computing multiple concurrent hashes over the same byte streams. For example, a content object has a SHA-256 hash over the entire message, while specific sub-strings of the message have other hashes, such as several cumulative SipHashes. The system uses a rule system to describe packets and then issues commands to multiple hashers operating on the same byte streams. A larger system may use a cross-connect between multiple input controllers and an array of available hashers. 
     The data structures and code described in this detailed description are typically stored on a computer-readable storage medium, which may be any device or medium that can store code and/or data for use by a computer system. The computer-readable storage medium includes, but is not limited to, volatile memory, non-volatile memory, magnetic and optical storage devices such as disk drives, magnetic tape, CDs (compact discs), DVDs (digital versatile discs or digital video discs), or other media capable of storing computer-readable media now known or later developed. 
     The methods and processes described in the detailed description section can be embodied as code and/or data, which can be stored in a computer-readable storage medium as described above. When a computer system reads and executes the code and/or data stored on the computer-readable storage medium, the computer system performs the methods and processes embodied as data structures and code and stored within the computer-readable storage medium. 
     Furthermore, methods and processes described herein can be included in hardware modules or apparatus. These modules or apparatus may include, but are not limited to, an application-specific integrated circuit (ASIC) chip, a field-programmable gate array (FPGA), a dedicated or shared processor that executes a particular software module or a piece of code at a particular time, and/or other programmable-logic devices now known or later developed. When the hardware modules or apparatus are activated, they perform the methods and processes included within them. 
     The above description is presented to enable any person skilled in the art to make and use the embodiments, and is provided in the context of a particular application and its requirements. Various modifications to the disclosed embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be applied to other embodiments and applications without departing from the spirit and scope of the present disclosure. Thus, the present invention is not limited to the embodiments shown, but is to be accorded the widest scope consistent with the principles and features disclosed herein.