Patent Publication Number: US-11658917-B2

Title: Selective offloading of bandwidth to enable large-scale data indexing

Description:
TECHNICAL FIELD 
     The disclosure generally relates to the field of database management, and more particularly relates to using secondary servers on-demand to offload indexing large-scale data sets. 
     BACKGROUND 
     Existing on-premises systems that integrate data provide locked data integrations in static formats that cannot be granularly searched beyond the naked data within the integration. This is due to huge data sets being used to output the locked data integrations, where processing used by on-premises systems is inadequate to retain more than defined values for static variables based on underlying data, where the underlying data is then discarded or stored elsewhere. 
    
    
     
       BRIEF DESCRIPTION OF DRAWINGS 
       The disclosed embodiments have other advantages and features which will be more readily apparent from the detailed description, the appended claims, and the accompanying figures (or drawings). A brief introduction of the figures is below. 
       Figure ( FIG.  1    illustrates one embodiment of a system environment of a data management service facilitating access to locked data. 
         FIG.  2    illustrates one embodiment of exemplary modules used by the data management service. 
         FIG.  3    illustrates one embodiment of a user interface operable by a client device to communicate information to the search service. 
         FIG.  4    is a block diagram illustrating components of an example machine able to read instructions from a machine-readable medium and execute them in a processor (or controller). 
         FIG.  5    illustrates one embodiment of an exemplary flowchart for a process for generating and providing for display integrated data from multiple aggregations. 
     
    
    
     DETAILED DESCRIPTION 
     The Figures (FIGS.) and the following description relate to preferred embodiments by way of illustration only. It should be noted that from the following discussion, alternative embodiments of the structures and methods disclosed herein will be readily recognized as viable alternatives that may be employed without departing from the principles of what is claimed. 
     Reference will now be made in detail to several embodiments, examples of which are illustrated in the accompanying figures. It is noted that wherever practicable similar or like reference numbers may be used in the figures and may indicate similar or like functionality. The figures depict embodiments of the disclosed system (or method) for purposes of illustration only. One skilled in the art will readily recognize from the following description that alternative embodiments of the structures and methods illustrated herein may be employed without departing from the principles described herein. 
     CONFIGURATION OVERVIEW 
     One embodiment of a disclosed system, method and computer readable storage medium is disclosed herein for receiving, by a server, based on input by a user into a user interface, a request to lock a set of data. For example, a user may periodically (e.g., monthly) request to lock data that reflects activity during the period. The data may be data that is stored and managed using cloud resources, as opposed to being stored and managed on-premises of a conglomerate. In response to receiving the request to lock the set of data the server may modify the set of data to be read-only data, thereby causing the set of data to become locked data. This may be performed, e.g., to comply with an electronic policy that periodic data cannot be edited once closed. 
     The server may determine whether an amount of bandwidth required to index the locked data exceeds a threshold, and, responsive to determining that the amount of bandwidth exceeds the threshold, the server may instruct a secondary server to allocate bandwidth to index a first portion of the locked data. In an embodiment, determining, by the server, whether the amount of bandwidth required to index the locked data exceeds a threshold includes determining that the amount of bandwidth required to index the locked data exceeds the threshold responsive to determining that, in the course of indexing the locked data, the threshold amount of bandwidth has been used. For example, where the threshold is 90%, and memory usage toward indexing crosses 90%, the server may determine that the amount of bandwidth required to index the locked data exceeds the threshold. 
     In an embodiment, determining, by the server, whether the amount of bandwidth required to index the locked data exceeds a threshold may include, prior to indexing the locked data, the server determining an amount of bandwidth required to index the locked data, comparing the determined amount to the threshold, and determining whether the amount exceeds the threshold based on the comparison. That is, before the indexing process, an estimated amount of bandwidth required may be determined. In performing this process, the server may determine the amount of bandwidth required to index the locked data by inputting a representation of the locked data into a machine-learned model, and receiving as output from the machine-learned model an amount of bandwidth required to index the locked data. The server may instruct the secondary server to reserve the output amount of bandwidth required to index the locked data. The machine-learned model may have been trained using data-label pairs of a representation of data size from prior data sets as paired to an amount of bandwidth required to index the prior data sets. 
     The server may index a second portion of the locked data in parallel with the secondary server indexing the first portion of the locked data, and may generate an index by collating the indexed first portion of the locked data and the indexed second portion of the locked data. Following indexing, the server may receive a search request for a portion of the locked data, and may retrieve the portion of the locked data based on referencing the index. 
     Exemplary Data Management Service System Environment 
     Figure ( FIG.  1    illustrates one embodiment of a system environment of a data management service facilitating access to locked data.  FIG.  1    depicts environment  100 , which includes client device  110 , application  111 , network  120 , data management service  130 , secondary server  140 , unlocked data  150 , locked data  160 , and locked data indices  170 . Client device  110  may be any device having a user interface operable by a user to communicate with data management service  130 . For example, client device  110  may be a mobile device (e.g., smartphone, laptop, tablet, personal digital assistant, wearable device, internet-of-things device, and so on), a larger device (e.g., a personal computer, kiosk, and so on), or any other device capable of operating application  111 . Application  111  may be installed on client device  110 , and may be used to interface a user of client device  110  with data management service  130 . Application  111  may be a dedicated application, provided to client device  110  via data management service  130 . Alternatively, application  111  may be a browser application through which a user may navigate to a portal to interface with data management service  130 . Application  111  may perform some or all functionality of data management service  130  on-board client device  110 . Further details about the functionality of application  111  will be described below with respect to search service  130 . 
     Network  120  facilitates communication between client device  110  and search service  130 . Network  120  may be any network, such as a local area network, a wideband network, the Internet, and any other type of network. 
     Data management service  130  facilitates a locking of unlocked data  150  based on a request from client device  110 , converting unlocked data  150  into locked data  160 . Data management service  130  also facilitates indexing the locked data, thus enabling a search mechanism. Data management service  130  may request indexing operations be performed by secondary server  140  in order to ensure sufficient bandwidth for performing the indexing operation (e.g., within a time constraint). Further details about the operation of data management service  130  are described below with reference to  FIG.  2   . 
     Secondary server  140  is accessed for additional processing bandwidth (e.g., computational resources, such as memory) in indexing locked data  160  responsive to the data becoming locked. Secondary server  140  receives instructions to index a portion of locked data  160  from data management service  130 . 
     Unlocked data  150  includes data that is editable by users. For example, users may be members of a conglomerate. The users may edit the unlocked data  150  (e.g., adjust parameters within the data). Locked data  160  is formed responsive to a user requesting to lock a set of data. Following the above example, users may request to lock unlocked data  150  on a periodic or aperiodic (e.g., monthly) basis, thus generating a set of locked data  160  during each prescribed term. Locking may be performed, e.g., to provide a snapshot of data at different time points. Unlocked data  150  and locked data  160  may be stored on the same or different databases. While only one set of unlocked data  150  and locked data  160  is depicted, any number of sets of unlocked data  150  and locked data  160  are within the scope of this disclosure. A user may be prompted to lock data at pre-determined time intervals (e.g., on a monthly basis, or on any other periodic or aperiodic basis), or responsive to a condition being met, the condition being associated with a lock event. 
     Locked data indices  170  includes a plurality of indexes, each index referencing a set of locked data  160  (e.g., each index referring to data within a locked set of data corresponding to a given interval of time). Locked data indices  170  may be used by data management service  130  to provide custom data integrations to client device  110 , the customization having been requested via application  111 . 
     Exemplary Data Management Service Functionality 
       FIG.  2    illustrates one embodiment of exemplary modules used by the data management service. As depicted in  FIG.  2   , data management service  130  includes user input module  231 , data locking module  232 , bandwidth determination module  233 , index module  234 , collation module  235 , and search module  236 . User input module  231  receives input from a user to lock a set of data. In an embodiment, user input module  231  prompts the user for input. For example, user input module  231  may determine whether a condition is met, and responsive to the condition being met, user input module  231  may prompt a user to provide input. An exemplary prompt may include a selectable option for locking a set of data. The set of data may be, for example, data populated between a last locking of data and a current time. Exemplary conditions may be time-based (e.g., a pre-defined amount of time, or a pre-defined date, has been reached). For example, a monthly prompt may occur on a certain date and/or time of the month. Exemplary conditions may be based on other metrics (e.g., a threshold amount of data has been populated, the threshold being at or within a predefined distance from a maximum amount of data that is to form a locked data set). In an embodiment, a prompt may indicate that data will be locked regardless of whether a selection of an option to lock the data is made. For example, a deadline may be indicated, where, at a certain time, the data will be locked, and user input module  231  may indicate the deadline in the prompt. In an embodiment, a deadline may exist, but is not included in such a prompt. 
     In an embodiment, user input module  231  may prompt the user with selectable options to lock a plurality of different sets of data, such as subsets of the unlocked data, or different discrete sets of unlocked data. Responsive to receiving a selection of each individual selectable option, its corresponding data may be locked (as is discussed with reference to data locking module  232 ). 
     In addition to prompting a user to, and receiving input from a user to, lock data, user input module  231  may receive a request from a user to generate an integration including the locked data. The integration may be configured to include any information desired by a user. User input module  231  may generate for display the data integration, and may modify the integration based on input from a user requesting further customizations. The data integration is generated based on one or more locked data sets indicated by the user via a user interface of application  111 . 
     Data locking module  232  converts unlocked data  150  into locked data  160  responsive to detection of a locking condition. In an embodiment, data locking module  232  receives information from user input module  231  that a locking condition has occurred (e.g., a user has selected a selectable option to lock the data). In an embodiment, data locking module  232  may detect that a condition for locking unlocked data  150  has occurred (e.g., a threshold amount of data is included in unlocked data  150 , a deadline has been reached, and the like), and responsively converts unlocked data  150  into locked data  160 . In order to convert unlocked data  150  into locked data  160 , data locking module  232  may convert the data into a read-only format. Data locking module  232  may apply additional security measures, such as encryption, password protection, and any other policy to prevent tampering by a user with locked data  160 . 
     Index module  233  indexes the locked data by generating an index that maps memory addresses and/or search terms to portions of the data such that the data may be organized and searched in a granular and customizable fashion. In an embodiment, a constraint is applied, where indexing is to occur within a predefined interval of time. For example, where the locked data is to be used to generate a data integration, a lack of speed in indexing the data would delay the integration or otherwise be limited to only enabling the integration to be generated in a static format that cannot be searched. 
     Bandwidth determination module  234  may be a standalone module, or a sub-module of index module  233 . Bandwidth determination module  234  determines whether the amount of bandwidth required to index the locked data using a primary server exceeds a threshold amount of bandwidth. The term primary server, as used herein, whether used in the singular or plural, may refer to one or more servers under ambit of data management service  130  that are available in whole or in part to perform the indexing operation. The threshold amount of bandwidth may be a processing capacity of data management service  130  and/or may be an amount representative of the processing capacity of the primary server (e.g., 90% capacity). The threshold may be predefined by an administrator. The threshold may adjust dynamically based on other processing demands placed on data management service  130  at the time the integration generation is initiated. comprise instructions to determine that the amount of bandwidth required to index the locked data exceeds the threshold responsive to determining that, in the course of indexing the locked data, the threshold amount of bandwidth has been used. 
     In an embodiment, bandwidth determination module  234  determines, prior to beginning to index the locked data, an amount of bandwidth that is required to index the locked data. Bandwidth determination module compares this determined amount to the threshold, and determines whether the amount exceeds the threshold in response to the comparison. Determining the amount of bandwidth that is required to index the locked data may be performed in a variety of different ways. In an embodiment, bandwidth determination module  234  determines a size of the locked data, and determines therefrom an amount of bandwidth required to index that size of locked data (e.g., based on processing capabilities of data management service  130  and/or one or more servers allocated to index the locked data). 
     In an embodiment, determining the amount of bandwidth that is required to index the locked data may be performed using a machine learning model. Bandwidth determination module  234  may input a representation of the locked data into a machine-learned model. The representation of the locked data may include any signals associated with the locked data, including data of the locked data, metadata of the locked data, properties of the locked data (e.g., size, format, etc.), and so on. Optionally, signals associated with data management service  130  and/or the primary server may also be input into the machine-learned model (e.g., processing capacity, hardware information, current memory usage, and so on). Optionally, the time constraint may also be input into the machine-learned model. Bandwidth determination module  234  may receive as output from the machine-learned model an amount of bandwidth required to index the locked data, and may use this amount to perform the above-mentioned comparison. In an embodiment, rather than output an amount of bandwidth required to index the locked data, the machine-learned model may directly output an indication of whether data management service  130  and/or the primary server have the capacity to do so (and, additionally alternatively, a specific amount of bandwidth that will need to be allocated to another server in order to process the indexing ahead of the constraint). 
     The machine-learned model may be trained using data-label pairs of a representation of data size from prior data sets as paired to an amount of bandwidth required to index the prior data sets. In addition to data size, any other signals relating to the data, the processor, and the time constraint may also be paired to amounts of bandwidth required to index the prior data sets. As data sets are indexed, new training data may be added to a training set, and the machine-learned model may be re-trained in order to improve accuracy of prediction. 
     In an embodiment, bandwidth determination module  234  determines, while the primary server is indexing the locked data, that the threshold amount has been crossed. This may be without having performed an initial determination of an amount of bandwidth required to index the locked data. In such an embodiment, bandwidth determination module  234  determines, responsive to determining that the threshold amount has been crossed, that the amount of bandwidth required to index the locked data exceeds a processing capacity of data management service  130  and/or the primary server. 
     Index module  233 , depending on the outcome of bandwidth determination module  234 , may determine that a secondary server is required to timely index the locked data (timely being relative to the aforementioned constraint). The term secondary server, as used herein, regardless of whether used in the singular or in plural, may refer to one or more servers that are additional to the initially allocated one or more servers for indexing the data. The secondary server may be a third-party server, or may be one or more additional servers under the ambit of data management service  130 . Where index module  233  determines that a secondary server is required, index module  233  instructs the secondary server to reserve additional bandwidth above and beyond the initially allocated one or more server&#39;s bandwidth to index the data and/or instructs the secondary server to begin indexing the locked data. 
     In an embodiment, index module  233  instructs the secondary server to index a particular portion of the locked data that is different from the portion of the locked data that is being indexed by the primary server. In an embodiment, the portions of data are selected on the relative processing capacity of the primary server as compared to additional bandwidth that will be required of the secondary server. 
     Collation module  235  collates the portions indexed by the primary and secondary server. Following collation, collation module  235  constructs a unified index that renders the locked data searchable. Collation module  235  may store the unified index to locked data indices  170 . Search module  236  may output a user interface to a user (e.g., via application  111 ) that accepts parameters for search. The parameters may include, e.g. a specification or one or more locked data sets, as well as fields from the selected one or more locked data sets that are to be searched. Search module  236  references locked data indices  170  to determine memory addresses of data matching the input parameters, and outputs a customized integration to client device  110  based on the input parameters. 
       FIG.  3    illustrates one embodiment of a user interface operable by a client device to communicate information to the search service. User interface  300  may be output using application  111  of client device  110 , and may be used to generate a custom integration of locked data that is indexed by data management service  130 . User interface  300  may include selectable options for selecting various parameters. Data set selection option  310  enables a user to select one or more locked data sets from which to generate the data integration. For example, where data is locked on a monthly basis, month options may be available for selection via data set selection option  310 . Data set parameters option  320  may include selectable options for selecting fields to be included in the custom data integration. The selectable options may dynamically populate depending on the data set selected (e.g., where some candidate fields are inapplicable to a given data set and thus omitted). This results in an improved user interface based on application usage, resulting in a more efficient set of options displayed to a user for navigating creation of a custom data integration. 
     Computing Machine Architecture 
       FIG.  4    is a block diagram illustrating components of an example machine able to read instructions from a machine-readable medium and execute them in a processor (or controller). Specifically,  FIG.  4    shows a diagrammatic representation of a machine in the example form of a computer system  400  within which program code (e.g., software) for causing the machine to perform any one or more of the methodologies discussed herein may be executed. The program code may be comprised of instructions  424  executable by one or more processors  402 . In alternative embodiments, the machine operates as a standalone device or may be connected (e.g., networked) to other machines. In a networked deployment, the machine may operate in the capacity of a server machine or a client machine in a server-client network environment, or as a peer machine in a peer-to-peer (or distributed) network environment. 
     The machine may be a server computer, a client computer, a personal computer (PC), a tablet PC, a set-top box (STB), a personal digital assistant (PDA), a cellular telephone, a smartphone, a web appliance, a network router, switch or bridge, or any machine capable of executing instructions  424  (sequential or otherwise) that specify actions to be taken by that machine. Further, while only a single machine is illustrated, the term “machine” shall also be taken to include any collection of machines that individually or jointly execute instructions  124  to perform any one or more of the methodologies discussed herein. 
     The example computer system  400  includes a processor  402  (e.g., a central processing unit (CPU), a graphics processing unit (GPU), a digital signal processor (DSP), one or more application specific integrated circuits (ASICs), one or more radio-frequency integrated circuits (RFICs), or any combination of these), a main memory  404 , and a static memory  406 , which are configured to communicate with each other via a bus  408 . The computer system  400  may further include visual display interface  410 . The visual interface may include a software driver that enables displaying user interfaces on a screen (or display). The visual interface may display user interfaces directly (e.g., on the screen) or indirectly on a surface, window, or the like (e.g., via a visual projection unit). For ease of discussion the visual interface may be described as a screen. The visual interface  410  may include or may interface with a touch enabled screen. The computer system  400  may also include alphanumeric input device  412  (e.g., a keyboard or touch screen keyboard), a cursor control device  414  (e.g., a mouse, a trackball, a joystick, a motion sensor, or other pointing instrument), a storage unit  416 , a signal generation device  418  (e.g., a speaker), and a network interface device  420 , which also are configured to communicate via the bus  408 . 
     The storage unit  416  includes a machine-readable medium  422  on which is stored instructions  424  (e.g., software) embodying any one or more of the methodologies or functions described herein. The instructions  424  (e.g., software) may also reside, completely or at least partially, within the main memory  404  or within the processor  402  (e.g., within a processor&#39;s cache memory) during execution thereof by the computer system  400 , the main memory  404  and the processor  402  also constituting machine-readable media. The instructions  424  (e.g., software) may be transmitted or received over a network  426  via the network interface device  420 . 
     While machine-readable medium  422  is shown in an example embodiment to be a single medium, the term “machine-readable medium” should be taken to include a single medium or multiple media (e.g., a centralized or distributed database, or associated caches and servers) able to store instructions (e.g., instructions  424 ). The term “machine-readable medium” shall also be taken to include any medium that is capable of storing instructions (e.g., instructions  424 ) for execution by the machine and that cause the machine to perform any one or more of the methodologies disclosed herein. The term “machine-readable medium” includes, but not be limited to, data repositories in the form of solid-state memories, optical media, and magnetic media. 
     Exemplary Indexing Process 
       FIG.  5    illustrates one embodiment of an exemplary flowchart for a process for generating and providing for display integrated data from multiple aggregations. Process  500  begins with a server (e.g., a primary server of data management service  130 ) receiving  502 , based on input by a user into a user interface (e.g., user interface  300 ), a request to lock a set of data (e.g., unlocked data  150 ). For example, a set of data representing data for a prior month may be requested to be locked. In response to receiving the request to lock the set of data, the primary server modifies  504  the set of data to read-only data (e.g., using data locking module  232 ), thereby causing the set of data to become locked data (e.g., locked data  160 ); 
     The primary server determines  506  whether an amount of bandwidth required to index the locked data exceeds a threshold (e.g., using bandwidth determination module  234 ). Responsive to determining that the amount of bandwidth exceeds the threshold, the primary server instructs  508  a secondary server to allocate bandwidth to index a first portion of the locked data (e.g., using index module  233 ). The primary server indexes  510  a second portion of the locked data in parallel with the secondary server indexing the first portion of the locked data (e.g., thus improving speed with which the data is indexed by having at least two servers indexing respective portions of the data at a same time). 
     The primary server generates  512  an index by collating the indexed first portion of the locked data and the indexed second portion of the locked data (e.g., using collation module  235 ). The primary server receives  514  a search request for a portion of the locked data (e.g., via user interface  300 , as operated by client device  110  using application  111 ). The primary server retrieves  516  the portion of the locked data based on referencing the index (e.g., using parameters input into user interface  300  to determine which portions of the index to reference). 
     ADDITIONAL CONFIGURATION CONSIDERATIONS 
     Throughout this specification, plural instances may implement components, operations, or structures described as a single instance. Although individual operations of one or more methods are illustrated and described as separate operations, one or more of the individual operations may be performed concurrently, and nothing requires that the operations be performed in the order illustrated. Structures and functionality presented as separate components in example configurations may be implemented as a combined structure or component. Similarly, structures and functionality presented as a single component may be implemented as separate components. These and other variations, modifications, additions, and improvements fall within the scope of the subject matter herein. 
     Certain embodiments are described herein as including logic or a number of components, modules, or mechanisms. Modules may constitute either software modules (e.g., code embodied on a machine-readable medium or in a transmission signal) or hardware modules. A hardware module is tangible unit capable of performing certain operations and may be configured or arranged in a certain manner. In example embodiments, one or more computer systems (e.g., a standalone, client or server computer system) or one or more hardware modules of a computer system (e.g., a processor or a group of processors) may be configured by software (e.g., an application or application portion) as a hardware module that operates to perform certain operations as described herein. 
     In various embodiments, a hardware module may be implemented mechanically or electronically. For example, a hardware module may comprise dedicated circuitry or logic that is permanently configured (e.g., as a special-purpose processor, such as a field programmable gate array (FPGA) or an application-specific integrated circuit (ASIC)) to perform certain operations. A hardware module may also comprise programmable logic or circuitry (e.g., as encompassed within a general-purpose processor or other programmable processor) that is temporarily configured by software to perform certain operations. It will be appreciated that the decision to implement a hardware module mechanically, in dedicated and permanently configured circuitry, or in temporarily configured circuitry (e.g., configured by software) may be driven by cost and time considerations. 
     Accordingly, the term “hardware module” should be understood to encompass a tangible entity, be that an entity that is physically constructed, permanently configured (e.g., hardwired), or temporarily configured (e.g., programmed) to operate in a certain manner or to perform certain operations described herein. As used herein, “hardware-implemented module” refers to a hardware module. Considering embodiments in which hardware modules are temporarily configured (e.g., programmed), each of the hardware modules need not be configured or instantiated at any one instance in time. For example, where the hardware modules comprise a general-purpose processor configured using software, the general-purpose processor may be configured as respective different hardware modules at different times. Software may accordingly configure a processor, for example, to constitute a particular hardware module at one instance of time and to constitute a different hardware module at a different instance of time. 
     Hardware modules can provide information to, and receive information from, other hardware modules. Accordingly, the described hardware modules may be regarded as being communicatively coupled. Where multiple of such hardware modules exist contemporaneously, communications may be achieved through signal transmission (e.g., over appropriate circuits and buses) that connect the hardware modules. In embodiments in which multiple hardware modules are configured or instantiated at different times, communications between such hardware modules may be achieved, for example, through the storage and retrieval of information in memory structures to which the multiple hardware modules have access. For example, one hardware module may perform an operation and store the output of that operation in a memory device to which it is communicatively coupled. A further hardware module may then, at a later time, access the memory device to retrieve and process the stored output. Hardware modules may also initiate communications with input or output devices, and can operate on a resource (e.g., a collection of information). 
     The various operations of example methods described herein may be performed, at least partially, by one or more processors that are temporarily configured (e.g., by software) or permanently configured to perform the relevant operations. Whether temporarily or permanently configured, such processors may constitute processor-implemented modules that operate to perform one or more operations or functions. The modules referred to herein may, in some example embodiments, comprise processor-implemented modules. 
     Similarly, the methods described herein may be at least partially processor-implemented. For example, at least some of the operations of a method may be performed by one or processors or processor-implemented hardware modules. The performance of certain of the operations may be distributed among the one or more processors, not only residing within a single machine, but deployed across a number of machines. In some example embodiments, the processor or processors may be located in a single location (e.g., within a home environment, an office environment or as a server farm), while in other embodiments the processors may be distributed across a number of locations. 
     The one or more processors may also operate to support performance of the relevant operations in a “cloud computing” environment or as a “software as a service” (SaaS). For example, at least some of the operations may be performed by a group of computers (as examples of machines including processors), these operations being accessible via a network (e.g., the Internet) and via one or more appropriate interfaces (e.g., application program interfaces (APIs).) 
     The performance of certain of the operations may be distributed among the one or more processors, not only residing within a single machine, but deployed across a number of machines. In some example embodiments, the one or more processors or processor-implemented modules may be located in a single geographic location (e.g., within a home environment, an office environment, or a server farm). In other example embodiments, the one or more processors or processor-implemented modules may be distributed across a number of geographic locations. 
     Some portions of this specification are presented in terms of algorithms or symbolic representations of operations on data stored as bits or binary digital signals within a machine memory (e.g., a computer memory). These algorithms or symbolic representations are examples of techniques used by those of ordinary skill in the data processing arts to convey the substance of their work to others skilled in the art. As used herein, an “algorithm” is a self-consistent sequence of operations or similar processing leading to a desired result. In this context, algorithms and operations involve physical manipulation of physical quantities. Typically, but not necessarily, such quantities may take the form of electrical, magnetic, or optical signals capable of being stored, accessed, transferred, combined, compared, or otherwise manipulated by a machine. It is convenient at times, principally for reasons of common usage, to refer to such signals using words such as “data,” “content,” “bits,” “values,” “elements,” “symbols,” “characters,” “terms,” “numbers,” “numerals,” or the like. These words, however, are merely convenient labels and are to be associated with appropriate physical quantities. 
     Unless specifically stated otherwise, discussions herein using words such as “processing,” “computing,” “calculating,” “determining,” “presenting,” “displaying,” or the like may refer to actions or processes of a machine (e.g., a computer) that manipulates or transforms data represented as physical (e.g., electronic, magnetic, or optical) quantities within one or more memories (e.g., volatile memory, non-volatile memory, or a combination thereof), registers, or other machine components that receive, store, transmit, or display information. 
     As used herein any reference to “one embodiment” or “an embodiment” means that a particular element, feature, structure, or characteristic described in connection with the embodiment is included in at least one embodiment. The appearances of the phrase “in one embodiment” in various places in the specification are not necessarily all referring to the same embodiment. 
     Some embodiments may be described using the expression “coupled” and “connected” along with their derivatives. It should be understood that these terms are not intended as synonyms for each other. For example, some embodiments may be described using the term “connected” to indicate that two or more elements are in direct physical or electrical contact with each other. In another example, some embodiments may be described using the term “coupled” to indicate that two or more elements are in direct physical or electrical contact. The term “coupled,” however, may also mean that two or more elements are not in direct contact with each other, but yet still co-operate or interact with each other. The embodiments are not limited in this context. 
     As used herein, the terms “comprises,” “comprising,” “includes,” “including,” “has,” “having” or any other variation thereof, are intended to cover a non-exclusive inclusion. For example, a process, method, article, or apparatus that comprises a list of elements is not necessarily limited to only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Further, unless expressly stated to the contrary, “or” refers to an inclusive or and not to an exclusive or. For example, a condition A or B is satisfied by any one of the following: A is true (or present) and B is false (or not present), A is false (or not present) and B is true (or present), and both A and B are true (or present). 
     In addition, use of the “a” or “an” are employed to describe elements and components of the embodiments herein. This is done merely for convenience and to give a general sense of the invention. This description should be read to include one or at least one and the singular also includes the plural unless it is obvious that it is meant otherwise. 
     Upon reading this disclosure, those of skill in the art will appreciate still additional alternative structural and functional designs for a system and a process for indexing large sets of locked data through the disclosed principles herein. Thus, while particular embodiments and applications have been illustrated and described, it is to be understood that the disclosed embodiments are not limited to the precise construction and components disclosed herein. Various modifications, changes and variations, which will be apparent to those skilled in the art, may be made in the arrangement, operation and details of the method and apparatus disclosed herein without departing from the spirit and scope defined in the appended claims.