Abstract:
Systems, methods, computer program products, and means are provided for verifying the integrity of data structures. A system includes a first data structure, a second data structure, and a fingerprint block. The first data structure has a first set of unique identifiers. The second data structure has a second set of unique identifiers. The fingerprint block verifies correspondence between the first and second data structures by performing a mathematical function on the first and second sets of unique identifiers to produce a result indicative of correspondence.

Description:
BACKGROUND 
     The following disclosure generally relates to file systems and methods for verifying the integrity of data structures. 
     Conventional file systems can store metadata associated with a file in several related data structures. The data structures, although organized in different ways, can have some data correspondence since they are sourced from the same metadata. However, data transfers into and out of the data structures can introduce correspondence errors and thereby corrupt the data structures. 
     Conventional file systems can periodically verify correspondence between data structures to identify correspondence errors. One conventional verification process is to count the number of files represented in each of the data structures, and compare the final count. If the counts match, a file system can assume correspondence. One problem with conventional verifications is a high collision rate. A collision occurs when the counts for two data structures are the same, despite the existence of correspondence errors. For example, both data structures can be missing a different file, but have the same count. 
     Another conventional verification process is to generate a list of files having a certain attribute for each data structure and compare lists. For large and unordered data structures, a large amount of memory is required to store lists of file names associated with an attribute as there can be millions or billions of file names in a data structure. Furthermore, an unordered data structure typically requires significant processing resources to cross-check lists. 
     SUMMARY 
     This disclosure generally describes systems, methods, computer program products, and means for verifying the integrity of data structures. In one implementation, the data structures can included a large number of unique identifiers that form an unordered data set. The unique identifiers can be associated with metadata. Correspondence between unique identifiers can be verified by performing a mathematical function on the data structures. In one example, the data structures are file structures having unique file names that are associated with extended attributes. In this example, correspondence between the unique file names can be verified by performing a modulo function against unique integers representing the unique file names to produce fingerprints (or hashes) for comparison. 
     In general, in one aspect, a method is provided. The method includes receiving a first data structure having a first set of unique identifiers; receiving a second data structure having a second set of unique identifiers; and verifying correspondence between the first and second data structures, including performing a mathematical function on the first and second sets of unique identifiers to produce a result indicative of correspondence. 
     In general, in another aspect, a method is provided. The method includes receiving a first data structure having first metadata; receiving a second data structure having second metadata; and verifying correspondence between the first and second data structures including, determining one or more result arrays representative of a correspondence between the first and second file data structures. 
     Particular implementations can include one or more of the following features. Verifying can include determining a result array with a modulo value. Verifying can include determining a result array with a modulo array. The first and second metadata can include integers to uniquely identify portions of the first and second data structures. The modulo array can include a set of integers, each integer being a relative prime to the set of integers. A least common multiple of the modulo array can be substantially larger than a total number of unique identifiers associated with the first and second metadata. Verifying can include filtering unique identifiers based on a query request; adjusting a value in a first result array for each file attribute of the first data structure that satisfies conditions of the query request; complementary adjusting a value in a second result array for each file attribute of the second data structure that satisfies conditions of the query request, and comparing of the first and second arrays to determine correspondence. Verifying can include filtering unique identifiers based on a query request; adjusting a value in a result array for each file attribute of the first data structure that satisfies conditions of the query request; complementary adjusting a value in the result array for each file attribute of the second data structure that satisfies the conditions of the query request; and determining that correspondence exists between the first and second data structures if the array includes zero values after complementary adjusting is complete. 
     The method can further include initializing verification responsive to one or more of a hardware power interruption, a software crash, a software exception, a time out, or a user selection from a user interface. The method can further include outputting results of verifying including a correspondence error flag. The method can further include performing a data repair responsive to a correspondence error between the first and second data structures. The first and second data structures can be associated with a file structure selected from the group containing a HFS (Hierarchical File System), UFS (Unix File System), NTFS (New Technology File System), and FAT (File Allocation Table). The first and second metadata can include file names and attributes associated with files. 
     In general, in another aspect, a method is provided. The method includes receiving a first data structure having unique integers associated with one or more file names; receiving a second data structure having the unique integers associated with the one or more file names, the second data structure organized differently from the first data structure; and verifying correspondence between the first and second data structures including, determining one or more arrays with a modulo array, each modulo value in the modulo array being a relative prime to the set of integers and the modulo array having a least common multiple that is greater than or equal to a total number of the unique integers, the one or more arrays representative of a correspondence between the first and second data structures. 
     In general, in another aspect, a method is provided. The method includes receiving a first data structure having first metadata associated with one or more files; receiving a second data structure having second metadata associated with the one or more files; initializing verification responsive to one or more of a power interruption, a software crash, a software exception, a time out or a user selection from a user interface; verifying correspondence between the first and second data structures including, determining one or more result arrays representative of a correspondence between the first and second data structures; outputting results of the verification including a correspondence error flag; and performing a data repair responsive to a correspondence error between the first and second data structures. 
     In general, in another aspect, a system is provided. The system includes a first data structure having first metadata associated with one or more files; a second data structure having second metadata associated with the one or more files; and a fingerprint block, in communication with the first and second data structures, to verify correspondence between the first and second data structures, the fingerprint block determining one or more result arrays representative of a correspondence between the first and second data structures. 
     Particular implementations can include one or more of the following features. The fingerprint block can include a modulo block to determine a result array with a modulo value. The fingerprint block can include a modulo block to determine a result array with a modulo array. The first and second metadata can include integers to uniquely identify portions of the first and second data structures. The modulo array can include a set of integers, each integer being a relative prime to the set of integers. A least common multiple of the modulo array can be substantially larger than a total number of unique identifiers associated with the first and second metadata. The fingerprint block can include a query block to filter unique identifiers based on a query request; a modulo block to adjust a value in a first result array for each file attribute of the first data structure that satisfies conditions of the query request and complementary adjust a value in a second result array for each file attribute of the second data structure that satisfies conditions of the query request; and a comparison block to compare the first and second result arrays to determine correspondence. The fingerprint block can include a query block to filter unique identifiers based on a query request; a modulo block to adjust a value in an array for each file attribute of the first data structure that satisfies conditions of the query request, and complementary adjust a value in the array for each file attribute of the second data structure that satisfies the conditions of the query request; and a comparison block to determine that correspondence exists between the first and second data structures if the array includes zero values after complementary adjusting is complete. 
     The system can further include an event monitor, in communication with the fingerprint block, to initialize verification in the fingerprint block responsive to one or more of a hardware power interruption, a software crash, a software exception, a time out, or a user selection from a user interface. The fingerprint block can output results of verifying including a correspondence error flag. The system can further include a data repair block, in communication with the fingerprint block, to perform a data repair responsive to a correspondence error between the first and second data structures. The first and second data structures can be associated with a file structure selected from the group containing a HFS (Hierarchical File System), UFS (Unix File System), NTFS (New Technology File System), and FAT (File Allocation Table). The first and second metadata can include file names and attributes associated with files. 
     In general, in another aspect, a system is provided. The system includes a means for receiving a first data structure having a first set of unique identifiers; means for receiving a second data structure having a second set of unique identifiers; and means for, in communication with the means for receiving the first data structure and the means for receiving the second data structure, verifying correspondence between the first and second data structures, including performing a mathematical function on the first and second sets of unique identifiers to produce a result indicative of correspondence. 
     In general, in another aspect, a computer program product is provided. The computer program product can be tangibly stored on a computer-readable medium, the product including instructions operable to cause a computer system to perform a method, including receiving a first data structure having a first set of unique identifiers; receiving a second data structure having a second set of unique identifiers; and verifying correspondence between the first and second data structures, including performing a mathematical function on the first and second sets of unique identifiers to produce a result indicative of correspondence. 
     Aspects of the invention may offer one or more of the following advantages. A proposed system checks data structure integrity with an efficient use of memory and processing resources. The proposed system can quickly process a large and unordered set of numbers. 
    
    
     
       DESCRIPTION OF DRAWINGS 
         FIG. 1  is a block diagram illustrating a proposed system to verify the integrity of data structures. 
         FIG. 2  is a block diagram illustrating a fingerprint block. 
         FIG. 3  is a flow diagram illustrating a method for verifying the integrity of data structures. 
         FIG. 4  is a flow diagram illustrating a method for comparing fingerprints in association with a data set A and a data set B. 
         FIG. 5  is a flow diagram illustrating an example of generating a fingerprint for a data set A. 
         FIG. 6  is a block diagram illustrating an example of generating a fingerprint for a data set B. 
         FIG. 7  is a schematic diagram illustrating a user interface. 
     
    
    
     DETAILED DESCRIPTION 
       FIG. 1  is a block diagram illustrating a system for maintaining data structure integrity. System  100  includes a data input/output block  110 , a data set A  120 , a data set B  130 , a fingerprint block  140 , an event monitor  150 , and a data repair block  160 . 
     Data input/output block  110  is coupled to lines  101   a,b  for data exchange with data set A  120  and data set B  130 . Lines  101   a,b  can be a bus, dedicated line, software port, or other type of communication channel. Data input/output block  110  can be, for example, a file system module, an operating system module, part of a software application, and the like. In one implementation, data input/output block  110  reads and/or writes information, such as file data and metadata associated with a file, to data sets A and B  120 , 130 . For example, an operating system using HFS (Hierarchical File System) can generate data structures and manage data correspondence between data sets A and B  120 , 130 . Verification of data correspondence can be due to, for example, entry of data into two different types of data structures, data replication or back-up, data migration, and the like. Besides, HFS, data input/output block  110  can use other file systems such as UFS (Unix File System), NTFS (New Technology File System), FAT (File Allocation Table), and the like. In another implementation, data input/output block  110  can populate fields in a data structure from attributes or characteristics associated with a file. For example, data input/output block,  110  can send to data sets A and B  120 , 130  a file name and an extended attributed flag as discussed in greater detail below. Data input/output block  110  can store files data separately from data sets A and B  120 , 130 . File data can be data files generated by a user, system file used by an operating system loaded from a CD, and the like. 
     Data set A  120  is coupled to line  101   a  for receiving, in one implementation, metadata associated with files. Data set A  120  is coupled to line  102   a  for receiving query requests from and sending query results to fingerprint block  140 . Data set A  120  can be stored, for example, as a volume, a data repository, a data container, a database, and the like. Data set A  120  can be stored in hardware such as a hard disk or volatile memory. Generally, data set A  120  can be a large set of unordered data (e.g., millions or more entries). In one implementation, data set A  120  can be a data structure associated with stored files such as a file system. Data set A  120  can include metadata having, for example, a file name, file attributes, and the like. The files can be stored in a separate database. In one implementation, a file name is represented as an integer. The integer can be determined from the file name and its path in the file system to uniquely identify the file name (i.e., integer serves as a unique identifier). Data set A  120  can be searched or filtered to generate subsets satisfying certain conditions as described below in association with  FIG. 2 . 
     Data set B  130  is coupled to line  101   b  for receiving metadata associated with files. In one implementation data set B  130  can be a data structure sourced from the same files and metadata as data set A  130 . Data set B  130  can be organized in an alternative format compared to data set A  120 . For example, where metadata includes file names and attributes, data set A  120  can be a data structure organized mainly by file names and each file name having attributes, whereas data set B  130  can be a data structure organized mainly by the attributes and each attribute having an associated file name. Thus, there is correspondence between data sets A and B  120 , 130 . Example data structures associated with data sets A and B  120 , 130  are discussed in more detail below in association with  FIGS. 5 and 6 . 
     Fingerprint block  140  is coupled to lines  102   a,b  for sending query requests and receiving query results in association with data sets A and B  120 , 130 . Fingerprint block  140  is also coupled to line  103  for receiving initialization information from event monitor  150 . Fingerprint block  140  is coupled to line  104  for sending integrity results to data repair block  160 . In one implementation, fingerprint block  140  verifies correspondence or data structure integrity between data sets A and B  120 , 130  with a mathematical function (e.g., modulo operation). Fingerprint block  140  can initialize verification in response to event information received from event monitor  150 . In response, fingerprint block  140  generates query requests based on how target data structures are organized. Fingerprint block  140  can analyze query results for correspondence and generate integrity results to, for example, initiate a data repair. Additional blocks associated with fingerprint block  140  and their operations are described in greater detail below. 
     Event monitor  150  is coupled to line  103  for sending the initialization information to fingerprint block  140 . Event monitor  150  can be, for example, a daemon executing as a background process, or a user interface module. In one implementation, event monitor  150  tracks states of, for example, hardware or software associated with system  100  to determine when an integrity check is needed. For example, event monitor  150  can be responsive to hardware power interrupts, software crashes, exceptions, time outs, or other events that potentially introduce errors into data transfers. In another example, event monitor  150  can be responsive to manual triggers through a user interface as described below in association with  FIG. 5 . Event monitor  150  generates the initialization information to include, for example, a command to check data structure integrity, or merely event information used by fingerprint block  140  to assess whether to perform an integrity check. 
     Data repair block  160  receives the integrity information from fingerprint block  140 . In one implementation, data repair block  160  reorganizes data structures of data sets A and/or B  120 , 130  to remove errors. In another implementation, data repair block  160  reports errors to, for example, an associated application program, and operating system, or a user. 
     System  100  can be implemented in hardware and/or software. For example, system  100  can be part of an operating system that supports a file system. 
       FIG. 2  is a block diagram illustrating fingerprint block  140 . Fingerprint block  140  includes a query block  210 , a modulo block  220 , and a comparison block  230 . 
     In one implementation, query block  210  generates search queries. In one implementation, query block  210  can parse an integrity check into several queries. For example, one data structure can have a unique identifier associated with multiple file attributes (e.g., unique identifier[A,B,C]). An additional data structure can have extended attributes with associated unique identifiers (e.g., A[unique identifiers], B[unique identifiers], C[unique identifiers]). In the example, query block  210  generates separate search queries related to each attribute and for each data structure. Query block  210  can use database search terms (e.g., SQL commands), filtering, sorting, and the like. 
     In one implementation, modulo block  220  analyzes the query results by generating fingerprints. A fingerprint can be an array or hash representing unique identifiers (e.g., integers) associated with a set of data. The search results can contain, for example, file names from the above described search queries. In one implementation, modulo block  220  can perform a serial analysis on the search results by incrementing values in a fingerprint associated with data set A  120  and decrementing values in the fingerprint associated with data set B  130 . In another implementation, modulo block  220  can perform a parallel analysis on the search results by incrementing values in separate fingerprints for data sets A and B  120 , 130 . 
     In one implementation, comparison block  230  checks the fingerprint, or fingerprints, to verify integrity, or lack thereof. For the serial example, comparison block  230  checks to see if the modulo array has all zeroes (i.e., a decrement to offset each increment). If there are all zeroes, there are no correspondence errors, outside of the possibility of a collision error described below. If there are not all zeroes, each of the increments was not offset by a decrement, indicative of a correspondence error. The comparison block  230  can generate integrity results which can include a correspondence error flag. 
       FIG. 3  is a flow diagram illustrating one implementation of a method  300  for checking data structure integrity. Metadata associated with files, and including a unique integer, are stored as data set A and data set B  310  (e.g., by input/output block  110  as data set A  120  and data set B  130 ). The files can be stored in data storage such as a hard disk. Metadata can be organized into a data structure specified by the type of file system in use (e.g., HFS, UFS, NTFS, or FAT). The file system can store metadata in alternative formats needed for different uses of metadata. For example, where metadata includes file names and attributes, data set A  120  can be a data structure from the perspective of file names and each file name having attributes, and data set B  130  can be a data structure from the perspective of the attributes and each attribute having an associated file name. 
     An initialization event is detected  320  (e.g., by event monitor  150 ). In one implementation, states of hardware and/or software are tracked to detect irregularities that can introduce errors in data structure integrity. For example, changes to a file structure stored in volatile memory that have yet to be backed up on nonvolatile memory can be lost in the event of a power interruption or software exception. In another example, a user or application can request an integrity check through a user interface. In one implementation, initialization events can be generated periodically in the absence of irregularities. In response to certain events, the verification process is initialized. 
     A correspondence between data sets A and B is verified by generating and comparing fingerprints  330  (e.g., by fingerprint block  140 ). In one implementation, a fingerprint is generated as a hash of the unique identifiers used to populate an array of remainders. The fingerprint provides a description of the data set which can be compared to a description of a different data set to determine correspondence, or lack thereof. The fingerprint is implemented with characteristics to achieve a predetermined level of reliability. In another implementation, the fingerprints can be compared during a boot-up process or the like where a relatively small amount of memory is available. Details associated with verification are described in more detail below in association with  FIG. 7 . 
     Verification results, which in one implementation include a correspondence error flag, are output  340  (e.g., to data repair block  160 ). The correspondence error flag can be set with a bit, for example, as an indication of an integrity failure, or can include a more detailed description of errors. In one implementation, repair processes are initialized in response to correspondence errors. 
       FIG. 4  is a flow diagram illustrating a method  400  for generating a fingerprint in association with a data structure. Search queries related to an integrity check are sent  410  (e.g., from query block  200 ). In one example, for an integrity check related to attribute X, a query for identifiers having an associated attribute X is sent to a data set A (e.g., identifier[X] is sent to data set A  120 ). Also, a query for file names associated with the attribute X is sent to a data set B (e.g., X[identifiers] is sent to data set B  130 ). 
     Unique identifiers associated with metadata that meet conditions of the query are identified as query results  420 . In one implementation, a data set is filtered to generate a subset of unique identifiers that meet the conditions. The subset can form an array of search results output (e.g., to modulo block  220 ). 
     A modulo array is input  430  (e.g., in modulo block  220 ). In one implementation, the modulo array is a group of moduli, e.g., m[1], m[2], . . . m[n]. The modulo array can have characteristics that increase the probability that a fingerprint is unique, which in turn, increases the reliability of integrity results. For example, the modulo array can be limited to integers for a memory-efficient implementation. The integers can have, in one implementation, a relative prime relationship. In contrast to a pure prime number that is only evenly divisible by itself and 1, a group of relative prime numbers have unique divisors with respect each other (e.g., 10 and 11 are relative prime even though 10 is divisible by 2; 10 and 12 are not relative prime since they are both divisible by 2). In another example, the modulo array can have a least common multiple that is greater than the total number of unique identifiers. Thus, a modulo array including [2,3] reliably supports up to six unique identifiers. Reliability increases with the least common multiple. As a result, a modulo array including [2,3,5] supporting six unique identifiers has a higher probability of producing a unique fingerprint without collision. A collision occurs when fingerprints associated with data sets having different data are identical, and thus, produce a false positive of data structure integrity when compared. 
     A modulo of a query result associated with data set A against a modulo array is calculated, and related values in the fingerprint are incremented  440 . In one implementation, the fingerprint includes a result array for each modulus. The result array is generated, in one implementation, by calculating a remainder for each unique identifier from each array value in the modulo array. Accordingly, a unique identifier is divided by a moduli to produce a quotient and a remainder. The remainder is recorded in the fingerprint by adjusting (e.g., incrementing) a result value in the result array. For a data set having only integers for unique identifiers, a modulus n has a result array with n result values (e.g., m[6] initially has a result array of {0,0,0,0,0,0}). The resulting fingerprint is representative of data set A and has a probability of uniqueness in accordance with the characteristics of the modulo array. 
     A modulo of a query result associated with data set B against the same modulo array is calculated, and related values in the modulo array are decremented  440 . Again, in one implementation, modulo values from the modulo array are applied against each unique identifier. The remainder is recorded in the fingerprint by complementary adjusting (e.g., decrementing) a result value in the result array. 
     Whether there are correspondence errors between data sets A and B is determined  450 . In the described serial operation, incrementing and decrementing results in a fingerprint having all zeroes when there is full correspondence. In one implementation, a parallel operation can subtract one fingerprint from another to generate a result fingerprint having all zeroes when there is full correspondence. A lack of correspondence will fail to decrement result values that have been incremented. 
       FIGS. 5 and 6  are flow diagrams  500 , 600  illustrating examples of generating fingerprints for an integrity check of file names and an extended attribute, X. The extended attribute can relate to a file category, a keyword describing a file, an application identification for applications associated with a file, and the like. 
     In  FIG. 5 , block  510  includes a query request to find file names with an associated attribute X. Table  515  includes a data set A. In this example, a file name serves to uniquely identify the file as an integer. The integers are unordered and contain four digits which support up to 9,999 unique file names. Also, extended attributes X and Y are associated with the file names and are indicated as such with a bit vector (i.e., a 1 indicative of an existence of the extended attribute). The file names can be mapped from a text string and maintained in a separate table. 
     Block  520  includes query results. Files  5000 ,  0506 , and  0305  each have a 1 in the bit vector of Table  515  for the bit corresponding to extended attribute X. Block  525  includes a modulo array of integers having a relative prime relationship. Block  530  includes a modulo of one of the modulo values, 7, applied against the query results. The operation 5000 modulo 7 leaves a remainder of 2; the operation 0506 modulo 7 leaves a remainder of 2; and the operation of 0305 modulo 7 leaves a remainder of 4. Modulos are also computed using the remaining modulo values in the modulo array of block  525 . 
     Block  540  includes the modulo results of modulo value 7. The remaining modulo results from the modulo array form the fingerprint for data set A in this example. 
     In  FIG. 6 , block  610  includes a query request to find file names associated with attribute X. Table  615  includes a data set B which can be populated from the same metadata used to populate table  515 . Block  620  includes query results and block  625  includes a modulo array matching the modulo array of  FIG. 5 . Block  630  includes a modulo of modulo value 7 against the query results. Block  640  includes the modulo results, and thus, fingerprint for data set B. 
     A comparison of fingerprints from  FIGS. 5 and 6  shows that full correspondence exists between data set A and B. 
       FIG. 7  is a schematic diagram illustrating an example user interface  700  to manually initialize integrity checking. User interface  700  includes a volume listing  702 , a verify disk button  704 , a status window  706 , and a repair disk button  708 . 
     Volume listing  702  shows data structures available for integrity checking. Verify disk button  704  allows a user to manually initialize an integrity check on a volume selected in volume listing  702 . Status window  706  displays information about progress of an integrity check to the user. Information in status window  706  can indicate whether the volume has any correspondence errors. Repair button  708  allows a user to attempt a repair on the corrupted data structures. 
     The invention and all of the functional operations described herein can be implemented in digital electronic circuitry, or in computer hardware, firmware, software, or in combinations of them. The invention can be implemented as a computer program product, i.e., a computer program tangibly embodied in an information carrier, e.g., in a machine-readable storage device or in a propagated signal, for execution by, or to control the operation of, data processing apparatus, e.g., a programmable processor, a computer, or multiple computers. A computer program can be written in any form of programming language, including compiled or interpreted languages, and it can be deployed in any form, including as a stand-alone program or as a module, component, subroutine, or other unit suitable for use in a computing environment. A computer program can be deployed to be executed on one computer or on multiple computers at one site or distributed across multiple sites and interconnected by a communication network. 
     Method steps of the invention can be performed by one or more programmable processors executing a computer program to perform functions of the invention by operating on input data and generating output. Method steps can also be performed by, and apparatus of the invention can be implemented as, special purpose logic circuitry, e.g., an FPGA (field programmable gate array) or an ASIC (application-specific integrated circuit). 
     Processors suitable for the execution of a computer program include, by way of example, both general and special purpose microprocessors, and any one or more processors of any kind of digital computer. Generally, a processor will receive instructions and data from a read-only memory or a random access memory or both. The essential elements of a computer are a processor for executing instructions and one or more memory devices for storing instructions and data. Generally, a computer will also include, or be operatively coupled to receive data from or transfer data to, or both, one or more mass storage devices for storing data, e.g., magnetic, magneto-optical disks, or optical disks. Information carriers suitable for embodying computer program instructions and data include all forms of non-volatile memory, including by way of example semiconductor memory devices, e.g., EPROM, EEPROM, and flash memory devices; magnetic disks, e.g., internal hard disks or removable disks; magneto-optical disks; and CD-ROM and DVD-ROM disks. The processor and the memory can be supplemented by, or incorporated in special purpose logic circuitry. 
     To provide for interaction with a user, the invention can be implemented on a computer having a display device, e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor, for displaying information to the user and a keyboard and a pointing device, e.g., a mouse or a trackball, by which the user can provide input to the computer. Other kinds of devices can be used to provide for interaction with a user as well; for example, feedback provided to the user can be any form of sensory feedback, e.g., visual feedback, auditory feedback, or tactile feedback; and input from the user can be received in any form, including acoustic, speech, or tactile input. 
     The invention can be implemented in, e.g., a computing system, a handheld device, a telephone, a consumer appliance, or any other processor-based device. A computing system implementation can include a back-end component, e.g., as a data server, or that includes a middleware component, e.g., an application server, or that includes a front-end component, e.g., a client computer having a graphical user interface or a Web browser through which a user can interact with an implementation of the invention, or any combination of such back-end, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication, e.g., a communication network. Examples of communication networks include a local area network (“LAN”) and a wide area network (“WAN”), e.g., the Internet. 
     The computing system can include clients and servers. A client and server are generally remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. 
     A number of implementations have been described. Nevertheless, it will be understood that various modifications may be made. In one implementation, for example, to measure a distribution of residues in a set of numbers (e.g., a set of numbers produced by a pseudorandom number generator). Accordingly, other implementations are within the scope of the following claims.