Abstract:
For balancing load, a forwarder can selectively direct data from the forwarder to a processor according to a loading parameter. The selective direction includes forwarding the data to the processor for processing, transforming and/or forwarding the data to another node, and dropping the data. The forwarder can also adjust the loading parameter based on, at least in part, feedback received from the processor. One or more processing elements can store values associated with one or more flows into a structure without locking the structure. The stored values can be used to determine how to direct the flows, e.g., whether to process a flow or to drop it. The structure can be used within an information channel providing feedback to a processor.

Description:
CROSS REFERENCE TO RELATED APPLICATIONS 
       [0001]    This application is related to and claims the benefit of priority to U.S. Provisional Patent Application Ser. No., 61/638,078 filed on Apr. 25, 2012, the entirety of which is hereby incorporated by reference. 
     
    
     GOVERNMENT INTERESTS 
       [0002]    Portions of this invention were made with U.S. Government support under contract/instrument Department of Energy SBIR DE-SC0004400 and DE-SC0006343. The U.S. Government has certain rights in the invention. 
     
    
     FIELD OF THE INVENTION 
       [0003]    The present invention generally concerns multiprocessor systems. More particularly, the invention concerns a system and its methods for forwarding flows, e.g., of packets, across a communication network using cyber-security aware policies. 
       BACKGROUND OF THE INVENTION 
       [0004]    In any network-based information system, there exist two basic functions: (1) moving of data from one node to another and (2) processing of such data. These two functions—being different from each other in their own nature—are generally mapped onto two fundamentally different types of resources which we will herein refer as the forwarders (capable of moving data) and the processors (capable of processing data), respectively. For instance, in the XV century, kingdoms taking the role of data processors communicated with each other using various types of forwarding resources such as boats or horses. More in modern times, computer hosts acting as data processors exchange information with each other using networks of forwarding nodes consisting of routers or switches. 
         [0005]    A main objective in such networked systems resides in the identification of optimal forwarding policies that maximize the total amount of data processed by the system per unit of time—commonly referred as the throughput of the system. Generally speaking, such objective can be met by conveying an optimal amount of feedback from the processors to the forwarders, which is then used by the latter to decide how data is forwarded. This concept is illustrated in  FIG. 1 , where the processor node  105  shares part of its output with the forwarder node  104 , which in turn uses such feedback  110  to execute a locally optimal forwarding decision  107 / 109 . The amount of information fed back  110  to the forwarders defines a continuum of possible designs: on one edge of this continuum, if no feedback at all is provided, the forwarders can only implement static forwarding policies, which in general are sub-optimal for systems dealing with a dynamic input; on the other edge, all the processing output generated from the processors is fed back to the forwarder, effectively replicating the processing function onto the forwarder and therefore breaking the nature of the networked architecture. In general, an optimal trade-off will therefore be found somewhere between these two limits. 
         [0006]      FIG. 2  presents an equivalent interpretation of this trade-off based on its cost analysis: a certain budget has to be distributed amongst the forwarder  201  and the processor nodes  202 ; the curve  204  corresponds to the set of possible designs derived by making such allocation and the cost isolines  203  represent lines of equal cost; with this configuration, the optimal design will be located where the curve of designs  204  is tangent to a cost isoline. 
       SUMMARY OF THE INVENTION 
       [0007]    Various embodiments described herein present new methods for the identification of such optimal trade-offs in the context of systems dedicated to the processing of cyber-security information. In particular, various embodiments can address the optimization problem introduced above. This is achieved by, in part, providing an architecture that is divided into two types of functional nodes: forwarders, which have the capability of moving data from one node to another; and processors, which have the capability of processing data to generate meaningful information. Forwarders and processors can be grouped together to form a higher level of functional abstraction called information processing cells. 
         [0008]    This architecture provides techniques to optimize the data and information workflow between forwarders and processors with the objective to maximize the performance of the information processing cell they are part of. 
         [0009]    In one embodiment, a new queuing algorithm—referred as Tail Early Dropping (TED) Queuing—is presented which is designed to track an optimal trade-off inside the continuum of possible forwarding versus processing allocations. While the algorithm can accommodate a large variety of targets, in one exemplary embodiment TED is used to minimize the number of cache misses in the system while maximizing the degree of information entropy fed into the processing nodes. 
         [0010]    In yet another embodiment, a new data structure—referred as the lock-free low false negatives (LF−) table—is presented with the following properties:
       (1) it can be concurrently written and read by multiple writers and readers, respectively;   (2) it does not require locks to ensure the correctness of its state;   (3) it can tolerate a low probability of false negatives but not false positives.       
 
         [0014]    In an exemplary embodiment, the problem of arbitrarily scaling up the performance of the cyber-security system is resolved using a fractal-like architecture where nodes at level L are functionally identical to nodes at level L-1 but with higher processing capability. In one embodiment, such architecture can be mapped onto a variety of processing+forwarding levels such as those made by processes+software IPC (inter-processor communication), cores+shared memory, processors+system buses, hosts+IO ports, and clusters+switching fabrics. 
         [0015]    In yet another embodiment, the fractal architecture in conjunction with the TED queuing algorithm and the LF− data structure are used to create a high-performance cell with both forwarding and processing capabilities constituting a basic optimized unit of processing in the overall architecture. 
         [0016]    Accordingly, in one aspect, various embodiments feature an article of manufacture, a method and/or a device (a cell) that facilitate load balancing. The cell includes a processor, a forwarder, a data channel, and an information channel. The processor and the forwarder can be a formed by suitably configuring one or more processing elements, e.g., using the computer readable instructions stored on the article of manufacture. The data an information channels can be formed using communication links and memory, and the information channel can receive feedback at the forwarder from the processor. 
         [0017]    The forwarder is adapted to: (i) selectively direct data from the forwarder to the processor via the data channel, according to a loading parameter of the cell, and (ii) adjust the loading parameter based on, at least in part, the received feedback. For example, the data can be forwarded to the processor, e.g., for processing, if the loading parameters takes on one value, and may not be forwarded to the processor if the loading parameter takes on a different value. In some embodiments, the forwarder is adapted to selectively direct data by forwarding data to the processor, transforming data and forwarding transformed data to a node different than the processor, dropping the data, or a combination of two of these alternatives. 
         [0018]    The loading parameter can represent a property of the cell and/or data such as congestion at the processor, an amount of information associated with a data unit, etc. The forwarder may be adapted to adjust the loading parameter by decreasing the loading parameter to cause reduction in congestion at the processor. Alternatively or in addition, the forwarder may increase the loading parameter to cause increase in an amount of information processed at the processor. 
         [0019]    In some embodiments, the forwarder is adapted to receive a flow. Typically, the received flow includes a sequence of N data units indexed from [0, N-1]. Each data unit includes an amount of information, and at least one data unit having a smaller index, e.g., d[i], includes a greater amount of information than another data unit having a greater index, e.g., d[j]. In the flow, typically the data units are received at the forwarder in the order of their indices, i.e., the data units having smaller indices (e.g., index i) generally arrive before the data units having a greater index (e.g., index j). The loading parameter is adjusted such that the data unit d[i] is forwarded to the processor and the data unit d[j] is not forwarded to the processor. This can cause the early arriving data unit having more information to be processed, and the later arriving data unit having less information not to be processed by the processor. That data unit may be dropped or may be forwarded to a different node. 
         [0020]    In one embodiment, each data unit d[l] includes a greater amount of information than any other data unit d[m], if index l is smaller than index m. The forwarder may be adapted to adjust the loading parameter such that data units d[0] through d[k-1] are forwarded to the processor and the data units d[k] through d[N-1] are dropped. The value of k is determined according to the loading parameter, and by adjusting the loading parameter the number of data units to be processed can be adjusted. 
         [0021]    In some embodiments, the processor includes a number of sub-processors. A number of processing elements can also be configured as sub-processors forming the processor. The data channel may include memory configured as a queue, and the information channel may include memory configured as a hash table. 
         [0022]    In another aspect, various embodiments feature an article of manufacture, a method and/or a system that facilitate load balancing at different levels. The system includes a number of levels, and each level includes a set of processors, a set of forwarders, a set of data channels, and a set of information channels. Each data channel is adapted for forwarding data from a corresponding forwarder within the set of forwarders at that level to a corresponding processor within the set of processors at that level. Each information channel is adapted for providing feedback to a corresponding forwarder from one or more processors at any level. Thus, a forwarder may receive feedback only from the corresponding processor, or in addition, from other processors at the same level. Alternatively or in addition, the forwarder may receive feedback from one or more processors at one or more other levels. Each forwarder is adapted for: (i) selectively directing data to the corresponding processor according to a loading parameter associated with the forwarder, (ii) receiving feedback from a corresponding processor, and (iii) adjusting the associated loading parameter based on, at least in part, the received feedback. 
         [0023]    One or more processors within the set of processors at a first level include a parameter (e.g., processor type, capacity, speed) that is lacking in or has a different value than at least one processor within the set of processors at a second level. For example, in one embodiment the system includes four levels. One or more processors at the first level include or consist essentially of a core; one or more processors at the second level include or consist essentially of a central processing unit (CPU); one or more processors at a third level include or consist essentially of a host computer; and one or more processors at a fourth level include or consist essentially of a local network. 
         [0024]    In another aspect, various embodiments feature an article of manufacture, a method and/or a system that facilitate processing a number of flows. The system includes a number of processing elements and a memory. A first processing element is configured to compute an index into a structure stored in memory. The structure can be a table, list, heap, etc. The computed index is based on, at least in part, a unique ID of the flow and a property of the structure. 
         [0025]    The first processing element is also configured to store a value in the structure at the location identified by the index. The stored value corresponds to the unique flow ID, and the value is stored if a specified condition associated with the flow is satisfied. The storing operation includes or consists essentially of an atomic operation, so that the entire structure or a portion thereof need not be locked if two or more processing elements simultaneously store values in the structure. 
         [0026]    A second processing element within the number of processing elements is configured to compute a value corresponding to the unique flow ID and the index, and to compare the computed value with the value stored at the location identified by the index. Typically, these values may match if a value associated with the flow were previously stored in the structure, which would have occurred if the condition associated with the flow were determined to be satisfied. The second processing element is also adapted to control processing of the flow based on, at least in part, a result of the comparison. For example, if the comparison is true, implying that the condition associated with the flow was satisfied, the second processing element may take one action, and if the comparison is false, the second processing element may take a different action. In some embodiments, the second processing element is further configured to read the value stored at the location identified by the index from the structure. 
         [0027]    In some embodiments, the structure includes a table, and the property of the structure includes a size of the table. The second processing element may be further configured to compute the value corresponding to the unique flow ID at least in part by computing a hash value based on the unique flow ID. 
         [0028]    The specified condition may include an indication that the flow is not to be processed, and the second processing element may be further configured to control processing of the flow, at least in part by directing processing of the flow if the indication is false and by dropping the flow if the indication is true. The flow may be forwarded to the first processing element for processing. As an alternative to dropping, the flow may be forwarded, with or without transformation, to another processing element within and/or outside the system. The first processing element may include a processor of a cell and the second processing element may include a forwarder of the cell. In some embodiments, the first processing element is configured to store the value associated with the flow simultaneously with the comparison being performed by the second processing element, without locking the structure. 
         [0029]    A third processing element within the number of processing elements may be configured to additionally compute another index into the structure stored in the memory. The other index is based on, at least in part, a unique ID of another flow and the property of the structure. The third processing element is also configured to additionally store, as an atomic operation, a value in the structure at the location identified by the other index, if a specified condition associated with the other flow is satisfied. The stored value corresponds to the unique flow ID of the other flow. The first processing element may be configured to store simultaneously with the additional storage performed by the third processing element, without locking the structure. 
         [0030]    Various embodiments of methods perform the operations performed by the embodiments of systems described above. Various embodiments of articles of manufacture include a non-transitory machine-readable medium storing instructions that, when executed by a machine, can configure a system including one or more processing elements and/or one or more communication links to perform the operations performed by the embodiments of systems described above. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0031]    Various embodiments of the present invention taught herein are illustrated by way of example, and not by way of limitation, in the figures of the accompanying drawings, in which: 
           [0032]      FIG. 1  illustrates a general configuration of an information processing cell, according to one embodiment; 
           [0033]      FIG. 2  illustrates a set of possible trade-offs presented according to different configurations of an information processing cell according to one embodiment; 
           [0034]      FIG. 3  depicts an embodiment of the information processing cell using a queue and a table data structure as data and information channels, respectively, according to one embodiment; 
           [0035]      FIG. 4  illustrates a heavy tail of a network flow, according to one embodiment; 
           [0036]      FIG. 5  illustrates cutting the tail of a heavy tail flow, according to one embodiment; 
           [0037]      FIG. 6  illustrates an embodiment of a Tail Early Dropping (TED) queuing method, while tracking the theoretical optimal TED threshold; 
           [0038]      FIG. 7  illustrates an embodiment of an information processing cell using a LF− table as the information channel; 
           [0039]      FIG. 8  illustrates a life cycle of an entry in a LF− data structure, indicating which states are false positives, false negatives, and true states; according to one embodiment; 
           [0040]      FIG. 9  illustrates a configuration of TED queuing and the LF− data structure in an information processing cell to help optimize the cell&#39;s internal workflow, according to one embodiment; 
           [0041]      FIG. 10  provides a logical interpretation of an information processing system understood as an optimization process of mapping data onto cells; and 
           [0042]      FIG. 11  illustrates an information processing system using a fractal (e.g., multi-level) architecture. 
       
    
    
     DETAILED DESCRIPTION OF THE INVENTION 
       [0043]    Referring to  FIG. 1 , which illustrates an exemplary embodiment of a basic information processing cell consisting of a forwarder  104 , a processor  105 , four data plane channels  106 - 107 - 108 - 109  and two information plane channels  110 - 111 . The input to the cell being a stream of data  101  and the outputs being another stream of data  102  and a stream of information  103 . In this context, data and information are understood in the following sense: we will refer to data as the complete set of raw signals that are transmitted between information processing cells, regardless of whether portions of these signals are relevant or not to the processor; and we will refer to information as the output generated by the processor obtained from transforming the pieces of data that are relevant to it. 
         [0044]    In one embodiment, the input stream of data  101  can take any format, including but not limited to, a spoken conversation, an analog electromagnetic signal, digital Internet Protocol-based packets, etc.; the output stream of data o_d  102  is a function f_d( ) of i, o=f_d(i); and the output stream of information o_i  103  is a function f_i( ) of i, o_i =f_i(i). 
         [0045]    The forwarder is responsible for receiving data and deciding how this data is forwarded. Its forwarding decision can be based on information received from information channel  110 . Upon receiving a piece of data d, the forwarder can decide to:
       Forward d or a copy of it to data channel  107  while applying a function f_d( ) to d.   Forward d or a copy of it to data channel  108 .   Drop d by forwarding it to data channel  109 .       
 
         [0049]    The processor is responsible for receiving data from data channel  108  and processing the data to extract information from it by applying function f_i( ). Upon extracting a new piece of information i, the forwarder can decide to:
       Forward i or a copy of it to information channel  110 .   Forward i or a copy of it to information channel  111 .       
 
         [0052]    In this embodiment, the division of labor between the forwarder and the processor is as follows:
       The forwarder has the capability to move data between any pairs of data channels but it does not have the capability to extract information from data.   The processor has the capability to extract information from data but it does not have the capability to move data between any pairs of data channels.       
 
         [0055]    In some embodiments, as shown in  FIG. 3 , the data plane communication channel  108  can be implemented using a queue and the information plane communication channel  110  can be implemented using a table data structure. 
         [0056]    Under congestion scenarios where the rate of the input data is higher than the processing capacity of the processor, it is unavoidable that some portions of the data will need to be dropped. In one embodiment, the data plane communication channel  108  is implemented using a queue which takes proactive measures in dropping portions of the data so as to avoid reaching such congestion scenarios. In particular, the queue can exploit the property of heavy tails which is often found in communication systems. Such property works as follows. Data is first assumed to be grouped into flows—for instance, a person skilled in the art can recognize that in the field of computer networks, examples of flows can be TCP/IP or UDP/IP connections. As some authors have identified, (Jose Gonzalez, Vern Paxson, Nicholas Weaver, Shunting: A Hardware/Software Architecture for Flexible, High Performance Network Intrusion Prevention, ACM Conference on Computer and Communications Security, November 2007), information inside such flows is generally not equally distributed. In particular, assume without loss of generality that data takes the format of a stream of bytes, let b_n be the n-th byte transmitted in a given flow and let l(b_n) be the amount of information carried by such byte; then, it is often the case that l(b_n) is a monotonically decreasing function with a heavy tail as illustrated in  FIG. 4 . This heavy tail nature of the data presents optimization opportunities as described next. 
         [0057]      FIG. 5  provides additional detail on one exemplary embodiment of the data plane communication channel  108 . Let A be a positive number and assume without loss of generality that input data is formatted as a stream of bytes. Then, in such embodiment, the queue is ruled by the following proactive procedures:
       1. Upon receiving byte n-th of a flow:
           1.1. If n&gt;λ drop the byte  109 , otherwise forward it into the queue  108 ;   
           2. Periodically, schedule the following actions:
           2.1. If the cell is congested, keep decrementing λ until the cell is not congested;   2.2. Otherwise, increment λ a certain positive amount;   
               
 
         [0063]    The above algorithm is herein referred as the tail-early dropping (TED) algorithm. The name stems from the fact that to prevent congestion, the algorithm prioritizes those bytes that are on the front of the tail of each flow, which carry the highest information according to the heavy tail principle. Such strategy aims at maximizing the value of the data passed to the processor from an information perspective. A person skilled in the art of information theory will also recognize the above algorithm as a strategy to help maximize the entropy of the system, since higher levels of information are associated with higher levels of entropy. 
         [0064]    The above TED algorithm should be understood as a general queuing policy that maximizes the amount of information conveyed to the processor, regardless of the format it takes. For instance, when data cannot be represented in terms of a stream of bytes, the notion of the n-th byte of a flow can be exchanged by the more general concept of duration. Using such interpretation, the parameter λ would refer to the time in which a flow has existed for more than λ units of time. Likewise, the decrementing and incrementing functions used in steps 2.1 and 2.2 can be generally implemented following a variety of strategies. In one specific embodiment, a queue can decide to take a more aggressive step in decrementing the value of A than in incrementing it—for instance, by decrementing the value using an exponentially decaying function and incrementing it using a linear function; such strategy would be considered conservative in that it would help reduce the risks of reaching congestion at the expense of dropping potentially valuable information. 
         [0065]    In one specific embodiment, if the memory system of the processor is implemented using a standard hierarchical architecture, the TED queuing algorithm can be used to help stabilize the system towards operating in a higher performance regime, as illustrated in  FIG. 6 . Without loss of generality, such systems can be modeled as operating in two different regimes: a cache regime  601  in which data fetch by the processor is with high probability found in its local cache; and a memory regime  602  in which data fetch by the processor is with high probability not found in the cache and hence it has to be fetch from main memory, incurring a performance penalty. The TED queuing algorithm can be used to steer the system towards operating inside a cache regime through the following procedure: if the system operates under a memory regime, the processor&#39;s performance will tend to be degraded due to extra latencies in fetching data from memory (rather than cache), increasing the chances of congestion; as the system reaches congestion, the TED queuing algorithm in step 2.1 reduces its threshold λ; such reduction will continue until the congestion is resolved, at which point the system is more likely to operate in a cache regime. In this configuration, the TED queuing algorithm provides a strategy to track the value of a theoretical λ cr    603  defined as the maximum value that λ can take while still operating under a cache regime. 
         [0066]    The TED queuing algorithm can be understood as a queuing policy which effectively prioritizes packets based on the heavy tails principle. In one embodiment, such technique can be used to optimize the performance of an information processing system dedicated to the extraction of cyber-security information. In this context, it is known that on average, flows carry more cyber-security relevant information on the head of a flow than on a tail. It is for instance on the head of a flow that information such as the source and destination, the type of communication, and most of the metadata related to that flow is conveyed. The main principle behind the TED algorithm is that under heavily congested scenarios, on average the system is better off dropping packets from the tail rather than the head of a flow. 
         [0067]    Various embodiments are also provided for the implementation of the information plane channel  110 . In scenarios in which the processor is implemented using multiple parallel sub-processors, the writing of feedback information into such information plane channel  110  by such sub-processors needs to generally be done in a synchronized manner to avoid the corruption of the channel. In one embodiment, depicted in  FIG. 7 , the communication channel  110  is implemented using a data structure with the following properties:
       Each row of the table corresponds to one and only one flow from the input stream of data;   Each row provides some type of state about the flow it represents.   The data structure can be concurrently written and read by multiple writers and multiple readers but it does not require locks to preserve the correctness of its elements.   It can tolerate a low probability of false negatives but not false positives.       
 
         [0072]    We will refer to this data structure as the lock-free/low false negatives table or the LF− table. 
         [0073]    In one embodiment, such table can be used to track the status of a flow, marking each flow with a binary value ON or OFF. For instance, such information can be used to inform the forwarder about which flows need to be dropped  109  and which need to be forwarded  107 - 108 . In general, any condition may be associated with a flow, and based on whether the condition is true or false, the flow can be processed, e.g., processed by a processing element, transformed, forwarded to another processing element, dropped, and a combination of two or more of these operations. 
         [0074]    Let id(c) be a unique identifier of a flow c and h( ) a hash function that takes as input a flow identifier and returns as output an integer. Let T[ ] be a one-dimensional table storing N integers. The write and read operations of the LF− table are done according to the following procedure: 
         [0000]      Initial state: T[e]=NULL for all e such that 0≦e&lt;N;
       Writer procedure:
           Upon detecting that c needs to be dropped, do:   
               
 
         [0000]        T[h ( id ( c ))modulo  N]=h ( id ( c ));       The above write operation is an atomic operation, allowing simultaneous write operations to different locations within the table, without having to lock the table for any one write operation. As used herein, simultaneously does not mean exactly at the same time, but within a duration of a single processor clock cycle.   Reader procedure:
           Upon receiving a packet from flow c, do:   
                 
         [0000]      If  T[h ( id ( c ))modulo  N]==h ( id ( c ))               Return ON;       Otherwise
               Return OFF;   
                         
         [0083]    The number of entries N, or the size of the table T, is a property thereof. In general, any suitable function that maintains various probabilities as described below, and facilitates atomic write operations can be used. The modulo N is also illustrative, and other methods of computing an index into a table are within the scope of the present invention. 
         [0084]    It can be demonstrated that an element in a data structure constructed using the LF− procedure above is in a positive state with probability p t , in a false negative state with probability p fn , and in a false positive state with probability p fp , where p fp &lt;&lt;p fn &lt;&lt;p t  and p t ≈1. A person skilled in the art will be able to verify the correctness of the LF− data structure by constructing the following procedure. 
         [0085]    Let e be an entry in the LF − table and consider through the following process the set of all possible states for element e along with the probability of such states and throughout all possible paths in its life cycle.  FIG. 8 . shows the set of possible transitions amongst all possible states of element e (true, false negative and false positive). We use the notation p s  to denote the probability that the next change of state leads to state s and p s     1     ,s     2    to denote the probability of changing to state s 2  conditioned that our current state is s 1 . 
         [0086]    Element e starts with a NULL  802  value, T[e]=NULL. Assume that a processor wants to mark a flow c 1  as ON and assume that h(id(c 1 )) mod N is equal to e. Then per the writer algorithm, we have that T[e]=h 1 , where h 1 =h(id(c 1 )). This state is a true state  803  as entry e stores a flow that is marked as ON. Now there exist only three events that can affect the state of e, each with a different probability of occurrence: p t,t , p t,fn  and p t,fp , where p t,t +p t,fn +p t,fp =1. We have that these three events are:
       With a probability p t,t , flow c 1  is no longer present in the cell. In this case, the value of T[e] continues to be h 1 , but this state is still a true state  803  because there is no flow in the system whose identifier hashes into element e.   With a probability p t,fn , a new flow c 2  arrives to the cell and the processor needs to mark it as ON, with h(id(c 2 )) mod N=e and h 2 =h(id(c 2 ))≠h(id(c 1 )). Then, we have that T[e]=h 2 ≠h 1 . This state generates a false negative  804  because flow c 1  ought to be dropped but the reader will not find it in the table.   With a probability p t,fp , a new flow c 3  arrives which needs to be marked as OFF, with h(id(c 3 )) mod N=e and h(id(c 3 ))=h(id(c 1 )). Then, we have that T[e]=h 1 =h 3 . This state generates a false positive  805  because flow c 3  will be dropped.       
 
         [0090]    Based on the above, a person skilled in the art will recognize that:
       p t,fn &lt;&lt;1, because p t,fn  corresponds to the collision probability of the hash function. While this probability is not negligible, it is much smaller than 1.   p t,fp &lt;&lt;p t,fn , because p t,fp  corresponds to the probability of two flows yielding the exact same hash value. (Notice that this probability is much smaller than the probability of a hash collision p t,fn ; that is because the size of the table is relatively much smaller than the size of the hash value space.)       
 
         [0093]    Since 1=p t,t +p t,fn +p t,fp , it must be that p t,t ≈1. 
         [0094]      FIG. 8  represents a simplification in that, in principle, there ought to be further possible false negative and positive states coming out from the two double-circle states  804 - 805 . However, the probability of reaching such states diminishes geometrically and, for the sake of simplifying the analysis, we will consider them negligible. 
         [0095]    The equations that rule the life cycle of one element in the LF −  table are as follows. First, for each state, the sum of the probabilities of all possible events must add up to one: 
         [0000]    
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           1 
                           = 
                           
                             
                               p 
                               
                                 t 
                                 , 
                                 t 
                               
                             
                             + 
                             
                               p 
                               
                                 t 
                                 , 
                                 fn 
                               
                             
                             + 
                             
                               p 
                               
                                 t 
                                 , 
                                 fp 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           1 
                           = 
                           
                             
                               + 
                               
                                 p 
                                 
                                   fn 
                                   , 
                                   fn 
                                 
                               
                             
                             + 
                             
                               p 
                               
                                 fn 
                                 , 
                                 t 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           1 
                           = 
                           
                             
                               p 
                               
                                 fp 
                                 , 
                                 fp 
                               
                             
                             + 
                             
                               p 
                               
                                 fp 
                                 , 
                                 t 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0096]    Then, the probabilities of going into each of the states can be calculated using the law of total probability as follows: 
         [0000]    
       
         
           
             
               
                 
                   { 
                   
                     
                       
                         
                           
                             p 
                             t 
                           
                           = 
                           
                             
                               
                                 p 
                                 t 
                               
                                
                               
                                 p 
                                 
                                   t 
                                   , 
                                   t 
                                 
                               
                             
                             + 
                             
                               
                                 p 
                                 fn 
                               
                                
                               
                                 p 
                                 
                                   fn 
                                   , 
                                   t 
                                 
                               
                             
                             + 
                             
                               
                                 p 
                                 fp 
                               
                                
                               
                                 p 
                                 
                                   fp 
                                   , 
                                   t 
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             p 
                             fn 
                           
                           = 
                           
                             
                               
                                 p 
                                 t 
                               
                                
                               
                                 p 
                                 
                                   t 
                                   , 
                                   fn 
                                 
                               
                             
                             + 
                             
                               
                                 p 
                                 fn 
                               
                                
                               
                                 p 
                                 
                                   fn 
                                   , 
                                   fn 
                                 
                               
                             
                           
                         
                       
                     
                     
                       
                         
                           
                             p 
                             fp 
                           
                           = 
                           
                             
                               
                                 p 
                                 t 
                               
                                
                               
                                 p 
                                 
                                   t 
                                   , 
                                   fp 
                                 
                               
                             
                             + 
                             
                               
                                 p 
                                 fp 
                               
                                
                               
                                 p 
                                 
                                   fp 
                                   , 
                                   fp 
                                 
                               
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0097]    Finally, the sum of the probabilities of all possible states must add up to one: 
         [0000]      1= p   t   +p   fn   +p   fp    (3)
 
         [0098]    Working out the algebra, we get: 
         [0000]    
       
         
           
             
               
                 
                   
                     p 
                     t 
                   
                   ≈ 
                   
                     1 
                     
                       ( 
                       
                         1 
                         + 
                         
                           
                             1 
                             - 
                             
                               p 
                               
                                 t 
                                 , 
                                 t 
                               
                             
                           
                           
                             p 
                             
                               fn 
                               , 
                               t 
                             
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
             
               
                 
                   
                     p 
                     fn 
                   
                   ≈ 
                   
                     
                       p 
                       
                         t 
                         , 
                         fn 
                       
                     
                     
                       ( 
                       
                         1 
                         - 
                         
                           p 
                           
                             fn 
                             , 
                             fn 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
             
               
                 
                   
                     p 
                     fp 
                   
                   ≈ 
                   
                     
                       p 
                       
                         t 
                         , 
                         fp 
                       
                     
                     
                       ( 
                       
                         1 
                         - 
                         
                           p 
                           
                             fp 
                             , 
                             fp 
                           
                         
                       
                       ) 
                     
                   
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
           
         
       
     
         [0099]    Since p t,fp &lt;&lt;p t,fn &lt;&lt;p t,t , we have that p fp &lt;&lt;p fn &lt;&lt;p t  and p t ≈1. 
         [0100]    In one embodiment, the LF− data structure is used to help optimize the workflow of processors performing cyber-security analysis on the input data. In this context, a common scenario is one in which a cyber-security analytic does no longer require to receive packets of a given flow. Among other reasons, this could be for instance because it no longer deems such flow to carry relevant information, or because it no longer knows how to process it (for instance, if the flow is encrypted). In one specific embodiment, the processors can use the LF− table to communicate a “PLEASE DO NOT FORWARD PACKETS FROM THIS FLOW TO ME ANYMORE” message to the forwarders. The forwarder would find such message encoded in the form of a binary flag stored in the LF− table and stop forwarding packets of that flow to the forwarder via the data plane channel  108 . 
         [0101]    As shown in  FIG. 9 , one TED queue and one LF− table can be used in conjunction to optimize the overall workflow within one information processing cell. Upon receiving data, the forwarder uses feedback information from the LF− table to make data forwarding or dropping decisions. The forwarder passes data to the processor via the TED queue, which under congestion scenarios takes a proactive role in dropping tails with little information or entropy. The processor receives the data, processes it, extracts information, and conveys part of it back to the LF− table so that the forwarder can use it to optimize its forwarding decisions, completing a full cycle of data and information flow. 
         [0102]    We now turn to the problem of scaling up or down the performance of one information processing system by using information processing cells as building blocks. Consider the following simple processing model:
       1. Sets of data D={d 1 , d 2 , . . . d n } that enter the system and leave after they are processed;   2. Sets of cells C={c 1 , c 2 , . . . c n } capable of processing data;   3. A mapping m( ) of data sets onto cells:       
 
         [0000]      m: D→C
 
         [0000]        d   i   →c   j   =m ( d   i )   (7)
       4. The following procedure running in an infinite loop:
           For each data d i  ∈ D entering the system, assign d i  to c j =m(d i ) and let c j  process d i .   
               
 
         [0108]    To maximize the performance of the system, the mapping function m( ) ought to be designed according to some optimization criterion. Since this optimization criterion will generally depend on the state of the system learned throughout time, an optimal mapping m opt ( ) of tasks can be generally expressed as follows: 
         [0000]      m opt : D→C
 
         [0000]        d   i   →c   j   =m   opt ( d   i   , K )   (8)
 
         [0109]    where K is a parameter reflecting the accumulated information gained by the system through the processing of data sets. 
         [0110]      FIG. 10  provides a graphical representation of the mapping function m ops ( ), consisting of two nodes (the mapper and the cells) connected by a closed-loop which implements the feedback parameter K. 
         [0111]    From a functional perspective,  FIG. 10  is identical to  FIG. 1 , with the roles of the forwarder  104  and the processor  105  taken by the mapper  1001  and the cells  1002 . 
         [0112]    Consider now the problem of scaling up the performance of the system in  FIG. 10 . To attain higher degrees of performance, the mapper and the cells will need to be decomposed into smaller elements. These elements will need to resolve on their own the same original mapping problem between data sets and cells. Applying the same original principle, their internal optimal mapping will also depend on the information gained through the processing of data sets. This iterative process leads to a fractal-like architecture, with every level exposing the same properties of the level above, albeit at a smaller scale. An example of this recursive view of the system is illustrated in  FIG. 11 , for a system with four levels. 
         [0113]    Using this technique, an arbitrary number of information processing cells can be connected with each other to form a larger processing system. At each level, the system is identical to the single information processing cell described in another embodiment. Each cell can process data to generate new pieces of information, and at the same time it can forward data to other cells based on information gained from the data itself. Cells operate independently but in a manner that the overall performance of the system is maximized. 
         [0114]    In one specific embodiment, one information processing system is composed of four fractal levels using cores, CPUs, hosts and networks, via the following configuration:
       Cores: Multiple cores in a single CPU forming one information processing cell. Data and information are shared/forwarded via main memory or cache.   CPUs: Multiple CPUs in a single host forming one information processing cell. Data and information are shared/forwarded via a CPU interconnect (for instance, a PCI bus).   Hosts: Multiple Hosts in a single local network forming one information processing cell. Data and information are shared/forwarded via a local network interconnect (for instance, a switch).   Local networks: Multiple networks in a single wide area network forming one information processing cell. Data and information are shared/forwarded via a wide area network interconnect (for instance, a router).       
 
         [0119]    It is clear that there are many ways to configure the device and/or system components, interfaces, communication links, and methods described herein. The disclosed methods, devices, and systems can be deployed on convenient processor platforms, including network servers, personal and portable computers, and/or other processing platforms. Other platforms can be contemplated as processing capabilities improve, including personal digital assistants, computerized watches, cellular phones and/or other portable devices. The disclosed methods and systems can be integrated with known network management systems and methods. The disclosed methods and systems can operate as an SNMP agent, and can be configured with the IP address of a remote machine running a conformant management platform. Therefore, the scope of the disclosed methods and systems are not limited by the examples given herein, but can include the full scope of the claims and their legal equivalents. 
         [0120]    The methods, devices, and systems described herein are not limited to a particular hardware or software configuration, and may find applicability in many computing or processing environments. The methods, devices, and systems can be implemented in hardware or software, or a combination of hardware and software. The methods, devices, and systems can be implemented in one or more computer programs, where a computer program can be understood to include one or more processor executable instructions. The computer program(s) can execute on one or more programmable processing elements or machines, and can be stored on one or more storage medium readable by the processor (including volatile and non-volatile memory and/or storage elements), one or more input devices, and/or one or more output devices. The processing elements/machines thus can access one or more input devices to obtain input data, and can access one or more output devices to communicate output data. The input and/or output devices can include one or more of the following: Random Access Memory (RAM), Redundant Array of Independent Disks (RAID), floppy drive, CD, DVD, magnetic disk, internal hard drive, external hard drive, memory stick, or other storage device capable of being accessed by a processing element as provided herein, where such aforementioned examples are not exhaustive, and are for illustration and not limitation. 
         [0121]    The computer program(s) can be implemented using one or more high level procedural or object-oriented programming languages to communicate with a computer system; however, the program(s) can be implemented in assembly or machine language, if desired. The language can be compiled or interpreted. 
         [0122]    As provided herein, the processor(s) and/or processing elements can thus be embedded in one or more devices that can be operated independently or together in a networked environment, where the network can include, for example, a Local Area Network (LAN), wide area network (WAN), and/or can include an intranet and/or the Internet and/or another network. The network(s) can be wired or wireless or a combination thereof and can use one or more communications protocols to facilitate communications between the different processors/processing elements. The processors can be configured for distributed processing and can utilize, in some embodiments, a client-server model as needed. Accordingly, the methods, devices, and systems can utilize multiple processors and/or processor devices, and the processor/processing element instructions can be divided amongst such single or multiple processor/devices/processing elements. 
         [0123]    The device(s) or computer systems that integrate with the processor(s)/processing element(s) can include, for example, a personal computer(s), workstation (e.g., Sun, HP), personal digital assistant (PDA), handheld device such as cellular telephone, laptop, handheld, or another device capable of being integrated with a processor(s) that can operate as provided herein. Accordingly, the devices provided herein are not exhaustive and are provided for illustration and not limitation. 
         [0124]    References to “a processor”, or “a processing element,” “the processor,” and “the processing element” can be understood to include one or more microprocessors that can communicate in a stand-alone and/or a distributed environment(s), and can thus can be configured to communicate via wired or wireless communications with other processors, where such one or more processor can be configured to operate on one or more processor/processing elements-controlled devices that can be similar or different devices. Use of such “microprocessor,” “processor,” or “processing element” terminology can thus also be understood to include a central processing unit, an arithmetic logic unit, an application-specific integrated circuit (IC), and/or a task engine, with such examples provided for illustration and not limitation. 
         [0125]    Furthermore, references to memory, unless otherwise specified, can include one or more processor-readable and accessible memory elements and/or components that can be internal to the processor-controlled device, external to the processor-controlled device, and/or can be accessed via a wired or wireless network using a variety of communications protocols, and unless otherwise specified, can be arranged to include a combination of external and internal memory devices, where such memory can be contiguous and/or partitioned based on the application. References to structures includes links, queues, graphs, trees, and such structures are provided for illustration and not limitation. References herein to instructions or executable instructions, in accordance with the above, can be understood to include programmable hardware. 
         [0126]    Although the methods and systems have been described relative to specific embodiments thereof, they are not so limited. As such, many modifications and variations may become apparent in light of the above teachings. Many additional changes in the details, materials, and arrangement of parts, herein described and illustrated, can be made by those skilled in the art. Accordingly, it will be understood that the methods, devices, and systems provided herein are not to be limited to the embodiments disclosed herein, can include practices otherwise than specifically described, and are to be interpreted as broadly as allowed under the law.