Abstract:
Techniques are disclosed for determining and validating provenance data in such data stream processing systems. For example, a method for processing data associated with a data stream received by a data stream processing system, wherein the system comprises a plurality of processing elements, comprises the following steps. Input data elements and output data elements associated with at least one processing element of the plurality of processing elements are obtained. One or more intervals are computed for the processing element using data representing observations of associations between inputs elements and output elements of the processing element, wherein, for a given one of the intervals, one or more particular input elements contained within the given interval are determined to have contributed to a particular output element. In another method, intervals are specified, and then validated by comparing the specified intervals against intervals computed based on observations.

Description:
CROSS REFERENCE TO RELATED APPLICATION 
       [0001]    The present application is related to U.S. patent application identified as Attorney Docket No YOR920070680US1, entitled “Method and Apparatus for Maintaining and Processing Provenance Data in Data Stream Processing System,” and filed concurrently herewith, the disclosure of which is incorporated herein. 
     
    
     FIELD OF THE INVENTION 
       [0002]    The present invention relates to data stream processing systems and, more particularly, to techniques for determining and validating provenance data in such data stream processing systems. 
       BACKGROUND OF THE INVENTION 
       [0003]    Many data sources around us produce high volume streams containing significant amounts of important information for specific applications. Example applications are video surveillance applications ingesting many video feeds to detect potential security breaches. Another example is continuous health monitoring where patients are surrounded with sensors emitting stream data into a stream processing infrastructure that analyzes the data to identify and report medically significant events to medical professionals. 
         [0004]    In most of these applications, it is important to track the provenance of every event generated by the system. By provenance, it is meant the origins and justification for the generation of events by the system. For instance, if a medical system suggests that a patient requires a drug dosage change, based on its analysis, the provenance of such an event would inform the medical professionals of the procedure and all the data points used for the generation of that alert. 
         [0005]    Typically, these provenance reports are manually obtained by leveraging data specified by developers during the design of their analysis. 
       SUMMARY OF THE INVENTION 
       [0006]    Principles of the invention provide techniques for determining and validating provenance data in such data stream processing systems 
         [0007]    For example, in one embodiment of the invention, a method for processing data associated with a data stream received by a data stream processing system, wherein the system comprises a plurality of processing elements, comprises the following steps. Input data elements and output data elements associated with at least one processing element of the plurality of processing elements are obtained. One or more intervals are computed for the processing element using data representing observations of associations between input elements and output elements of the processing element, wherein, for a given one of the intervals, one or more particular input elements contained within the given interval are determined to have contributed to a particular output element. 
         [0008]    In another embodiment, a method for processing data associated with a data stream received by a data stream processing system, wherein the system comprises a plurality of processing elements, comprises the following steps. Input data elements and output data elements associated with at least one processing element of the plurality of processing elements are obtained. One or more intervals are specified for the processing element wherein, for a given one of the intervals, one or more particular input elements contained within the given interval are believed to have contributed to a particular output element. The one or more specified intervals are validated by computing one or more intervals for the processing element using data representing observations of associations between input elements and output elements of the processing element, and comparing the one or more specified intervals and the one or more computed intervals. 
         [0009]    Advantageously, such inventive techniques are able to determine dependencies between input data elements and output data elements for one or more processing elements in the data stream processing system. That is, dependency equations may be determined allowing the system to identify which input stream elements were used in the generation of a given output stream element. 
         [0010]    These and other objects, features and advantages of the present invention will become apparent from the following detailed description of illustrative embodiments thereof, which is to be read in connection with the accompanying drawings. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0011]      FIG. 1  illustrates a graph of analysis components, according to an embodiment of the invention. 
           [0012]      FIG. 2  illustrates a data format, according to an embodiment of the invention. 
           [0013]      FIG. 3  illustrates a method for dominant component analysis, according to an embodiment of the invention. 
           [0014]      FIG. 4  illustrates a method for input-output dependency equation generation, according to an embodiment of the invention. 
           [0015]      FIG. 5  illustrates a method for validating a provenance model, according to an embodiment of the invention. 
           [0016]      FIG. 6  illustrates a provenance system, according to an embodiment of the invention. 
           [0017]      FIG. 7  illustrates a computer system in accordance with which one or more components/steps of the techniques of the invention may be implemented, according to an embodiment of the invention. 
       
    
    
     DETAILED DESCRIPTION 
       [0018]    Embodiments of the present invention will be explained below in the context of an illustrative data stream processing system. However, it is to be understood that the present invention is not limited to any particular data processing system. Rather, the invention is more generally applicable to any data processing system in which it would be desirable to determine and validate provenance data. As illustratively used herein, the term “provenance” is defined as “origin” or “source.” Thus, for example, provenance data (or provenance information) is meta-information that documents the origin or source data, generally where that data was derived from other data through, for example, complex, multi-layered analysis. Also, the term “empirical” as used herein is defined as “provable or verifiable by experience or experiment.” We characterize computations to be “offline” when they are given the entire inputs in advance [for example, see http://www.nist.gov/dads/HTML/offline.html]. In contrast, on-line computations gradually incorporate newly received inputs in the computations. 
         [0019]    The illustrative real-world, practical application of principles of the invention is the domain of healthcare. Specifically, in the healthcare domain, one might envision a stream processing infrastructure that takes, as input, streams of medical information such as streams of electroencephalogram (EEG) or electrocardiogram (ECG) data as well as blood pressure, weight, or even glucometer readings. The stream processing infrastructure would apply analytic algorithms to these data streams and identify significant medical events that warrant further attention from a doctor or other medical professional. In such a system, it is important to give the medical professional as much information about the generation of the significant medical event as possible, including meta-information, referred to herein as provenance data, such as what subsets of the streams triggered the significant medical event and what specific processing elements contributed to its generation. The medical professional who receives the alert generated by the stream processing system may issue a provenance query related to the alert, where the provenance query is a request to show or reveal the stream data items and the stream processing nodes that contributed to the generation of the alert. Again, it is to be appreciated that while the solution domain mentioned in this embodiment is healthcare, principles of the invention apply to any domain where processing of data streams can be applied. 
         [0020]    In particular, as will be explained, illustrative principles of the invention provide automated generation of dependency equations in a stream provenance system. In addition, we present techniques to validate dependency equations specified by developers, against derived dependency equations generated automatically by our system. In an illustrative embodiment, we propose a Provenance Dependency Deriver (PDD) component that is added to the stream processing system and that observes, for any given stream processing component, the sequence of input data elements (belonging to one or more distinct streams) and the corresponding sequence of output data elements. The job of the PDD is to treat the processing component as a black box and simply learn, on the basis of the observed data, the time-windows of input data that seem to empirically affect the generation of a corresponding output data element. Hence, a main goal of the PDD component is to establish a time-invariant temporal dependency function. In general, the PDD component establishes a relationship of the form: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       e 
                       i 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                   ⇐ 
                   
                     
                       ⋃ 
                       
                         
                           j 
                           : 
                           
                             
                               S 
                               j 
                             
                              
                             
                                 
                             
                              
                             is 
                              
                             
                                 
                             
                              
                             input 
                              
                             
                                 
                             
                              
                             to 
                              
                             
                                 
                             
                              
                             
                               PE 
                               i 
                             
                           
                         
                          
                         
                             
                         
                       
                     
                      
                     
                       
                         
                           ⋃ 
                           
                             L 
                             j 
                           
                         
                         
                           k 
                           = 
                           1 
                         
                       
                        
                       
                         { 
                         
                           
                             e 
                              
                             
                               : 
                             
                              
                             e 
                           
                           ∈ 
                           
                             
                               S 
                               j 
                             
                              
                             
                               ( 
                               
                                 
                                   start 
                                   jk 
                                     
                                     
                                     
                                   
                                     t 
                                     - 
                                   
                                 
                                 , 
                                 
                                   end 
                                   jk 
                                     
                                     
                                     
                                   
                                     t 
                                     - 
                                   
                                 
                               
                               ) 
                             
                           
                         
                         } 
                       
                     
                   
                 
               
               
                 
                   ( 
                   1 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Here, L j  is the number of distinct disjoint ‘time intervals’ which define the values of S j  on which e i (t) depends, and start jk  and end jk  define the boundaries of these intervals. The term ‘time-invariant’ refers to the fact that the terms start jk  and end jk  are themselves independent of t; as a consequence, the dependence of a derived event to other input data elements can be expressed succinctly and completely independently of the specific timestamp or ID (identifier) of each sample. A main goal here is to try to infer the values of the terms start jk  and end jk . In many practical cases, the temporal dependency model can be simplified to the specification of a single (per-stream) interval term Δ j  (for each input stream S j ), such that the dependency is purely on the most recent window of input events: 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       e 
                       i 
                     
                      
                     
                       ( 
                       t 
                       ) 
                     
                   
                    
                    
                   
                     PE 
                     i 
                   
                    
                   
                     { 
                     
                       e 
                       ∈ 
                       
                         
                           S 
                           j 
                         
                          
                         
                           ( 
                           
                             t 
                             , 
                             
                               t 
                               - 
                               
                                 Δ 
                                 j 
                               
                             
                           
                           ) 
                         
                       
                     
                     } 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0000]    Here, Δ j  represents the past “time-window” associated with input stream S j . 
         [0021]    By way of example, we can use one of several different sets of techniques to ascertain the values of these terms. A first illustrative approach is applicable to processing components that are known to perform ‘linear’ (i.e., affine) transformations of the input data using principal component analysis or the Karhunen-Loeve transform [see Digital Pictures Representation, Compression and Standards (Applications of Communications Theory), Arun N. Netravali, Barry G. Haskell, Plenum Press, 1995, the disclosure of which is incorporated herein]. Another illustrative approach is to model our components with linear systems and perform impulse response or frequency response tests to estimate a transfer function. From this transfer function, the input-output dependencies can be obtained. 
         [0022]    Another illustrative approach, and the one described further below, uses information theoretic constructs to measure input output correlations and infer input output dependencies. This approach makes no assumptions on the components and applies to the general class of linear and non-linear transformations. It involves the use of empirical joint probability distribution functions and the computation of information-theoretic concepts, such as entropy and mutual information. For example, we can start by computing a sequence of conditional entropies between the output Y and increasingly longer input sequences X(.). In other words, we compute H(Y(t)); H(Y(t)|X(t)), H(Y(t)|X(t), X(t−1), H(Y(t)|X(t),X(t−1),X(t−2)) . . . and so on, where H(Y(t)) refers to the Shannon entropy [see C. E. Shannon, “A mathematical theory of communication,” Bell System Technical Journal, vol. 27, pp. 379-423 and 623-656, July and October, 1948, the disclosure of which is incorporated herein] of the random variable Y(t). In general, as long as there is some dependence, the additional conditioning will result in the reduction of the conditional entropy. Thus, we can keep computing the conditional entropies (based on the empirical distributions), until we reach a value L such that H(Y|X,X−1, X−(L+1)) results in no or insignificant reduction in entropy compared to H(Y|X, X(t−1), X(t−L)) or the entropy itself drops below an acceptable maximal value. We can then declare L to be the appropriate time interval for which dependence has been observed. 
         [0023]    In addition to this basic description, there are many other details, illustrating many different variants of this invention. One key aspect of the invention is the use of the PDD based dependency functions to perform validation of externally specified dependencies. In particular, the system may compare the empirically derived dependency values with the values externally (e.g., manually) specified for a stream processing component and note the extent of divergence. If the degree of divergence is high, this may be an indicator of either an incorrectly specified dependency function or some faulty operation of the actual processing logic in the stream processing component. In many situations, such automatic identification of potential faults or anomalies can prove invaluable as a tool for validation or early fault detection. 
         [0024]    While the basic description above refers to inferring the temporal dependency from the observed input and output values, principles of the invention also accommodate situations where the processing component can be fed (in a simulated or test environment) with specific input samples generated by the PDD itself. In this case, the derived dependency function can often be more accurate, as the sequence or set of input elements can often be chosen more intelligently to represent a wider sample space. For example, in medical stream analysis environments, it is possible that certain input values occur only rarely or under significant anomalies (e.g., heart rate readings below 40); as such, during normal operation, the stream processing system would be likely not to observe such input conditions. However, using simulated values allows the PDD to observe the input-output dependency over a much wider range of operating parameters. 
         [0025]    While the invention has so far described only a basic temporal model of dependency, the techniques of the invention can also be applied to learn or infer some alternate models of dependency, assuming of course, that the ‘model’ of dependency is externally provided. For example, if the dependency is declared to be in terms of the ‘number of past elements’ and not in terms of time windows, then the inventive approach can be applied here as well. We simply have to form an empirical matrix as described in  FIG. 2 , using appropriate sequences of input elements X in the appropriate columns, and then apply the techniques as before to determine the ‘sequence interval’ L (instead of a time interval). 
         [0026]    The method described above can either be applied offline (to a set of stored input and output streams) or online. In the offline case, principles of the invention provide for the PDD to access a set of stored input and output streams (over an appropriately defined history) and use this set as a ‘learning sequence’ to derive the dependencies. In the online model, the PDD can continually observe the incoming input elements and the generated output elements, and then incrementally construct a larger empirical matrix, and thus continually derive more-refined estimates of the dependency values as the empirical matrix evolves. 
         [0027]    The method described so far is blind—it tries to ascertain the empirical dependencies using all samples of input and output elements, potentially increasing the time window until the dependency function (e.g., the conditional entropy) is observed to remain steady (below a specified threshold) or the resulting entropy is small enough. However, principles of the invention can also be combined with additional prior specifications that refine the selected set of input elements that are used in the empirical derivation process. For example, the processing component may have some external specifications (e.g., indicating that it only utilizes heart rate readings taken on Monday mornings or blood pressure readings taken while in the gym); the PDD can apply such externally-specified filters to first reduce the vector space of input data elements that may be potentially associated with an output element. The subsequent technique of determining the appropriate minimal set of input elements remains the same. 
         [0028]    The method described can also be applied to construct equivalence classes of temporal or sequence-based provenance dependence-conceptually, an equivalence class may be defined to a set of output values (a subset of the range of output values) such that all members of this set have an identical or similar dependence function over their corresponding input elements. Such a situation arises, for example, if the output from a processing component is dependent on the past 100 values if the output value is greater than 40, but dependent on the past 1000 samples if the output is less than 40. Such segmentation of the window of dependency can be done either blindly (without any prior segmentation of the output range) or with the help of prior specifications on the output segments (in which case, principles of the invention can still be used to determine if multiple segments can be combined into one equivalence class). 
         [0029]    Such segmentation helps to further refine the provenance dependency-instead of defining a broad window of dependence for all output values, the method described above can potentially associate a more restricted and accurate window of dependence for certain ranges of output values. Moreover, forming as many elements as possible into one equivalence class also reduces the storage space needed to store the derived provenance dependency functions. In particular, a simple embodiment of this approach would be to first partition the output space into an appropriate set of partitions, and assign the empirically observed output elements into their corresponding partitions. The statistical analysis techniques described above can then be applied on each partition of data independently to derive its temporal or sequence-based dependence. If the derived dependence for multiple partitions turns out to be identical (or within a specified tolerance, such as the length of the time window Δ being within +/−2 of each other), then the partitions may be replaced by one equivalent partition, with one corresponding combined dependency function. 
         [0030]    Exemplary systems and methods for supporting multi-user collaborative software development environments will now be discussed in greater detail with reference to the exemplary figures in which the same reference numbers denote the same or similar elements. It is to be understood that the systems and methods described herein in accordance with the present invention may be implemented in various forms of hardware, software, firmware, special purpose processors, or a combination thereof. In particular, in one exemplary embodiment, systems and methods of the invention are implemented in software comprising program instructions that are tangibly embodied on one or more program storage devices (e.g., hard disk, magnetic floppy disk, RAM, CD ROM, DVD, ROM and flash memory), and executable by any device or machine comprising suitable architecture. 
         [0031]    It is to be further understood that because the constituent system modules and method steps depicted in the accompanying figures can be implemented in software, the actual connections between the system components (or the flow of the process steps) may differ depending upon the manner in which the application is programmed. Given the teachings herein, one of ordinary skill in the related art will be able to contemplate these and similar implementations or configurations of the present invention. 
         [0032]      FIG. 1  shows a graph of analysis components. This graph has eight processing elements (PE):  100 ,  110 ,  120 ,  130 ,  140 ,  150 ,  160 , and  170 . The processing elements are connected via communication paths represented by the directional arrows connecting them. As each processing element processes the stream according to its individual algorithm, which could perform any computation on the stream of data, the processing element passes the resultant output to the next processing element according to the connections in the graph. We can illustratively describe the subject of the invention as the problem of learning, at each processing element, dependency equations that allow the system to identify which input stream elements were used in the generation of a given output stream element. As shown in  FIG. 1 , data streams arriving on the ports  111 ,  121 ,  131 ,  132 ,  141 ,  142 ,  152 ,  153 ,  161 ,  162 ,  171 , and  172  are input to respective processing elements and elements are output by the respective processing elements on the corresponding output ports  101 ,  112 ,  113 ,  122 ,  123 ,  133 ,  134 ,  143 ,  151 ,  163 ,  164 , and  173 . In  FIG. 1  it may be observed that the data elements arriving at ports  111 ,  121  and  132  are identical, corresponding to the data elements generated by the output port  101 . 
         [0033]      FIG. 6  depicts an illustrative architecture for the system. Data sources  605  generate events and provide these events for display in an analysis graph  610  of processing elements. Alternately, the events may be generated by the Probe Generator  615 , which is specifically generating input events that help in the more accurate or more exhaustive derivation of the dependency windows. The persistency of all streams of events flowing in the graph is performed by a storage manager  620  into a data store  625 . To statistically infer input-output dependency equations, empirical probability distributions are estimated. The empirical distribution estimator  630  accesses the data store  620  to estimate these distributions. These distributions are used by the dominant component analysis module  635  to identify the position in the input streams of the component that is mainly responsible for the generation of the output. It is inside the dominant component analysis module  635  that conditional entropies and mutual information estimates are computed from empirical probability distributions to identify dominant components in the input. These dominant components are the parts of the input that are mostly responsible for the value of the output for a given processing element. 
         [0034]    Once such components are identified, the I-O (input-output) Dependency Equation Generator  640  generates I-O dependency equations and stores them in the provenance store  645 . The Provenance Dependency Deriver  642  is in essence composed of the Dominant Component Analysis module  635  and the I-O Dependency Equation Generator  640 . These dependency equations can also be used by the provenance model validator  650  to validate the compliance of provenance I-O dependency assertions made by application developers at the Integrated Development Environment  655 . 
         [0035]      FIG. 3  depicts a preferred embodiment for the method used to perform the dominant component analysis of module  635 . This analysis starts ( 310 ) with a preparation of the data ( 312 ) in an empirical matrix, in the format shown in  FIG. 2 . Essentially, streams are vectorized, into vectors  215 ,  220 ,  225 ,  230 ,  235  of size M. To each of these vectors is attached an output element  240 ,  245 ,  250 ,  255 ,  250  corresponding to the output Y t  generated for the corresponding input vector. Once the data is prepared, a set of variables are initialized ( 315 ) for the dominant component analysis. The set F of features of interest is set. Its cardinality (initially M) is stored in the variable K. An empty set F s  of dominant features is initialized. Finally, the Shannon entropy [see C. E. Shannon, “A mathematical theory of communication,” Bell System Technical Journal, vol. 27, pp. 379-423 and 623-656, July and October, 1948, the disclosure of which is incorporated herein] of the output process Y t  is computed and assigned to the variable pH. In the next step ( 320 ), for each feature X t-i  belonging to F, the conditional entropy H(Y t |X t-i ) is computed. In step  325 , the X t-i  with the lowest conditional entropy H(Y t |X t-i , F s ), is selected from F and added ( 330 ) to F s . In the next step ( 335 ), a conditional mutual information I cond  is computed by taking the difference between pH and H(Y t |F S ). 
         [0036]    If I cond  is greater ( 340 ) than a predefined threshold mDelta, then we conclude that the current feature set F S  contributes to the prediction of Y t . To further test if the dependency of Y t  on F S  is high enough, we test ( 345 ) the value of H(Y t |F S ). If this value is ( 345 ) below a threshold hDelta, we return F S  ( 350 ) as the output of the analysis and end the computation ( 370 ). If this value is above hDelta, we remove X t-i  from F and resume the computation at step  325 , if F is not empty ( 360 ). If I cond  is smaller ( 340 ) than mDelta, X t-i  is removed from F ( 355 ) and the computation resumed at step  360 . 
         [0037]      FIG. 4  shows a flow chart of a preferred embodiment for the computation taking place inside the I-O Dependency Equation Generator  640 . In this embodiment, the computation starts ( 410 ) with a generation ( 415 ) of a binary mask vector Xmask from the dominant terms computed by the dominant component analysis module  635 . Xmask is a binary vector of size M, with elements Xmask[i] equal to one if the term at position i in X is dominant. Conversely, Xmask[i] is equal to zero if the term at position i in X is not dominant. The next step ( 420 ) initializes variables needed for the rest of the computation. These variables are counters “k” and “j” which are set to 0, a binary state variable “s” which is set to 0, and a string “output” which is initially empty. The counter k tracks the number of features processed by this module. Consequently, its maximal value is M. j is used to track run lengths of 0 and 1 in Xmask. 
         [0038]    The next step reads the value of Xmask[k] ( 425 ). We then test the value of Xmask[k] and compare it with s ( 430 ). If Xmask[k] is not equal to s, we append “j*(NOT Xmask[k]),” to the output string ( 435 ), and set ( 440 ) j to 0, s to Xmask[k]. (NOT Xmask[k]) refers to the binary inversion of the Xmask[k] bit. The computation then executes step  450 . If Xmask[k] is equal to s, j is incremented by 1 ( 445 ) and the computation then executes step  450 . In step  450 , k is incremented by 1. The next steps check if we have read all the elements of Xmask ( 455 ). This is done by checking if k is less or equal to M. If the answer is true, we have more elements to process and the computation loops back to step  425 . If the answer is no, the next step is to use the output, which is a run length encoding of Xmask, and translate it into an I-O dependency equation ( 460 ), before storing it ( 462 ) in the provenance store. The computation ends in step  465 . 
         [0039]      FIG. 5  shows a technique proposed for the computation taking place inside the provenance model validator ( 650  in  FIG. 6 ). The computation starts ( 510 ) by reading learned I-O dependency equations for a given processing element ( 520 ), followed by a read of developer specified I-O dependency equations. The next step evaluates differences between what the system has evaluated and what the developer has specified. If the difference is greater than epsilon ( 550 ), according to an arbitrary distance metric, a non-compliance alert is issued ( 570 ). This alert might be consumed by an administrator. Otherwise, if the distance is less or equal to epsilon, we record a compliance message ( 550 ). 
         [0040]    Lastly,  FIG. 7  illustrates a computer system in accordance with which one or more components/steps of the techniques of the invention may be implemented. It is to be further understood that the individual components/steps may be implemented on one such computer system or on more than one such computer system. In the case of an implementation on a distributed computing system, the individual computer systems and/or devices may be connected via a suitable network, e.g., the Internet or World Wide Web. However, the system may be realized via private or local networks. In any case, the invention is not limited to any particular network. 
         [0041]    Thus, the computer system shown in  FIG. 7  may represent one or more servers or one or more other processing devices capable of providing all or portions of the functions described herein. Alternatively,  FIG. 7  may represent a mainframe computer system. 
         [0042]    The computer system may generally include a processor  705 , memory  710 , input/output (I/O) devices  715 , and network interface  720 , coupled via a computer bus  725  or alternate connection arrangement. 
         [0043]    It is to be appreciated that the term “processor” as used herein is intended to include any processing device, such as, for example, one that includes a CPU and/or other processing circuitry. It is also to be understood that the term “processor” may refer to more than one processing device and that various elements associated with a processing device may be shared by other processing devices. 
         [0044]    The term “memory” as used herein is intended to include memory associated with a processor or CPU, such as, for example, RAM, ROM, a fixed memory device (e.g., hard disk drive), a removable memory device (e.g., diskette), flash memory, etc. The memory may be considered a computer readable storage medium. 
         [0045]    In addition, the phrase “input/output devices” or “I/O devices” as used herein is intended to include, for example, one or more input devices (e.g., keyboard, mouse, etc.) for entering data to the processing unit, and/or one or more output devices (e.g., display, etc.) for presenting results associated with the processing unit. 
         [0046]    Still further, the phrase “network interface” as used herein is intended to include, for example, one or more transceivers to permit the computer system to communicate with another computer system via an appropriate communications protocol. 
         [0047]    Accordingly, software components including instructions or code for performing the methodologies described herein may be stored in one or more of the associated memory devices (e.g., ROM, fixed or removable memory) and, when ready to be utilized, loaded in part or in whole (e.g., into RAM) and executed by a CPU. 
         [0048]    In any case, it is to be appreciated that the techniques of the invention, described herein and shown in the appended figures, may be implemented in various forms of hardware, software, or combinations thereof, e.g., one or more operatively programmed general purpose digital computers with associated memory, implementation-specific integrated circuit(s), functional circuitry, etc. Given the techniques of the invention provided herein, one of ordinary skill in the art will be able to contemplate other implementations of the techniques of the invention. 
         [0049]    Although illustrative embodiments of the present invention have been described herein with reference to the accompanying drawings, it is to be understood that the invention is not limited to those precise embodiments, and that various other changes and modifications may be made by one skilled in the art without departing from the scope or spirit of the invention.