RU2574833C2 - Multiflow data elements sorting in electronic tables - Google Patents

Abstract

FIELD: physics.

SUBSTANCE: claimed process comprises the division of data elements in electronic table into multiple sets and the application of multiple flows for sorting of the data elements in said units. After sorting of the data elements in said units, said multiple units are combined by computation system for generation of the final result unit containing each of the data elements in electronic table. Each of combined flow combines two initial units for generation of the result unit. Each initial unit is either one of sorted units or one of the result units generated by the other combination flow. Sorted version of electronic table is displayed. Note here that the data elements in electronic table sorted version are ordered in compliance with the order of data elements in the final result unit.

EFFECT: accelerated process.

15 cl, 9 dwg

Description

BACKGROUND OF THE INVENTION

[0001] Spreadsheet applications allow users to view and manipulate tabular data. For example, a spreadsheet application may allow a user to view and manipulate a spreadsheet containing rows for various products and columns for various warehouse stores. In this example, cells contain values that indicate inventories of products in warehouses. In many cases, users want to be able to sort rows in spreadsheets. Continuing with the previous example, the user may want to sort the rows in the spreadsheet based on how much a particular warehouse contains for each product. In other cases, users want to be able to sort columns in spreadsheets. Continuing the previous example, the user may want to sort the columns in the spreadsheet based on how many specific products are in each warehouse.

[0002] In large spreadsheets, the process of sorting rows in a spreadsheet can be relatively slow. Such processing delays can disrupt the user's thinking or prevent the user from sorting rows in a spreadsheet. Therefore, it is desirable to make the process of sorting rows in a spreadsheet as fast as possible.

SUMMARY OF THE INVENTION

[0003] The sorting process is performed in a spreadsheet. During the sorting process, the data elements in the spreadsheet are divided into many blocks. Many threads are used to sort data items in blocks. After the data elements in the blocks are sorted, many combined threads are used to generate the block of the final result. The end result block contains each of the data elements in the spreadsheet. Each of the combined threads is a thread that combines the two source blocks to generate a result block. Each of the source blocks is either one of the sorted blocks, or one of the result blocks generated by another one of the combined threads. The sorted version of the spreadsheet is then displayed. Data elements in a sorted version of a spreadsheet are ordered according to the order of data elements in the end result block.

[0004] This summary is provided to introduce a selection of concepts. These concepts are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is this summary intended to assist in determining the scope of the claimed subject matter.

BRIEF DESCRIPTION OF THE DRAWINGS

[0005] FIG. 1 is a block diagram illustrating an example of a computing system.

[0006] FIG. 2 is a block diagram illustrating an example alternative embodiment of a computing system.

[0007] FIG. 3 is a flowchart illustrating an example operation for sorting a spreadsheet.

[0008] FIG. 4 is a diagram showing an example flow tree.

[0009] FIG. 5 is a flowchart illustrating an example operation performed by a sheet stream during a combining phase of a sorting process.

[0010] FIG. 6 is a flowchart illustrating an example operation performed by an incomplete internal thread.

[0011] FIG. 7 is a flowchart illustrating an example operation performed by a full internal thread.

[0012] FIG. 8 is a flowchart illustrating an example operation performed by a memory control stream during a combining phase of a sorting process.

[0013] FIG. 9 is a block diagram illustrating an example computing device.

DETAILED DESCRIPTION

[0014] FIG. 1 is a block diagram illustrating an example computing system 100. Computing system 100 is a system comprising one or more computing devices. As used herein, a computing device is a physical material device that processes information. In various embodiments, the computing system 100 comprises various types of computing devices. For example, computing system 100 may include one or more desktop computers, laptops, netbooks, handheld computing devices, smartphones, stand-alone servers, ultra-compact servers, general purpose computers, supercomputers, and / or other types of computing devices. In embodiments where the computing system 100 comprises more than one computing device, the computing devices in the computing system 100 may be distributed at various locations and communicated using a communication system such as the Internet or a local area network.

[0015] As illustrated in the example of FIG. 1, the computing system 100 comprises a data storage system 102, a processing system 104, and a display system 106. It should be appreciated that in other embodiments, the computing system 100 includes more or fewer components than are illustrated in the example of FIG. 1. In addition, it should be appreciated that FIG. 1 shows a computing system 100 in a simplified form for ease of understanding.

[0016] The storage system 102 is a system comprising one or more computer-readable storage media. A computer-readable storage medium is a physical device or manufacturing product that is capable of storing data in a volatile or non-volatile manner. In some embodiments, the data storage system 102 comprises one or more computer-readable storage media that are non-portable. Exemplary types of computer-readable storage media include random access memory (RAM), read-only memory (ROM), optical media (e.g., CD-ROM, DVD, BluRay, HDDVD, etc.) magnetic disks (for example, hard disks, floppy disks, etc.), solid state memory devices (for example, flash memory devices), EEPROM memory, user-programmable gate arrays, and so on. In some embodiments, where the data storage system 102 includes more than one computer-readable storage medium, computer-readable storage media is distributed across different geographical locations.

[0017] The data storage system 102 stores computer readable instructions representing a spreadsheet application 108. In some embodiments, where the storage system 102 comprises more than one computer-readable storage medium, computer-readable instructions representing a spreadsheet application 108 are distributed across two or more computer-readable storage media. In other embodiments, where the storage system 102 includes more than one computer-readable storage medium, computer-readable instructions representing a spreadsheet application 108 are stored on only one of the computer-readable storage media.

[0018] The processing system 104 is a system comprising a plurality of processing units 110A-110N (collectively, “processing units 110”). In various embodiments, the processing system 104 comprises a different number of processing units. For example, processing system 104 may comprise one, two, four, eight, sixteen, thirty two, sixty four, or another number of processing units. Each of the processing units 110 is a physical integrated circuit. Each of the processing units 110 executes computer-readable instructions asynchronously from the other processing units 110. As a result, processing units 110 can independently execute computer-readable instructions in parallel to each other. In some embodiments, one or more processing units 110 may individually issue two or more processing units. Computer-readable instructions can independently operate on logical processing units and may otherwise work as real processing units.

[0019] The display system 106 is a system used by the processing system 104 to display information to a user. In various embodiments, the display system 106 displays information to the user in various ways. For example, in some embodiments, the display system 106 comprises a graphical interface and a monitor.

[0020] The processing units 110 in the processing system 104 execute computer-readable instructions that represent a spreadsheet application 108. Computer-readable instructions that represent the spreadsheet application 108, when executed by processing units 110, force the computing system 100 to provide the spreadsheet application 108. Spreadsheet application 108 allows a user to view and manipulate one or more spreadsheets. Spreadsheets are data that are organized as a table having one or more rows and one or more columns. A spreadsheet may contain various types of data. For example, tabular data may be commercial data, accounting data, military data, billing data, statistical data, population data, demographic data, financial data, medical data, sports data, scientific data, or any other type of sortable data, which may be presented in the table.

[0021] Cells in a spreadsheet may contain values having various data types. For example, the values in cells can be integers, real numbers, floating point numbers, alphanumeric text strings, dates, monetary numbers, null values, and so on. In addition to the values in the cells, each of the cells can have many other properties. For example, each cell can have a background color property, a font color property, one or more flag properties, a visibility property, a font style property, a font size property, and so on.

[0022] The spreadsheet application 108 is able to use multiple streams to perform the sorting process on the spreadsheet. A stream is a part of a program that can work independently of and simultaneously with other parts of the program. The sorting process can be performed with respect to the rows or columns of the spreadsheet. For ease of explanation, this document describes how to perform a sort operation on rows in a spreadsheet. However, it should be appreciated that, unless otherwise indicated, consideration in this document regarding a row applies equally to columns. The term "data item" is used in this document to refer, in general, to a row or column.

[0023] The sorting process sorts the rows in the spreadsheet. In various cases, the spreadsheet may be a complete spreadsheet in a spreadsheet, part of a spreadsheet, or other type of spreadsheet. In addition, in some embodiments, the user of the spreadsheet application 108 selects a spreadsheet.

[0024] Furthermore, in some embodiments, the spreadsheet may be a pivot table. A pivot table is a spreadsheet that summarizes one or more other tabular datasets, such as spreadsheets, relational database tables, online analytical processing (OLAP) data cubes, other types of multidimensional datasets, and other types of tabular datasets. In some embodiments, the user is able to compile a pivot table by selecting a row with a column designation and a column designating a column designation in the source table. The values in the cells in the row with the column designation become the row designations of the pivot table. The values in the column cells with the column designation become the column designations of the pivot table. The value in each cell of the pivot table is calculated from the values of the cells in the column with the column designation, which have the same value as the row designation of the row of the pivot table containing the pivot table cell. The pivot table may also include cells that have values calculated from the values in the cells of the pivot table. For example, a pivot table may include cells containing total or count values in columns or rows of a pivot table. In some embodiments, users are also able to create pivot tables by selecting rows from the source table instead of columns from the source table.

[0025] In some embodiments, the user is able to select two or more columns with a line designation and a column with a column designation. In such embodiments, combinations of values in the column cells with the row designation become the row designations of the rows in the pivot table and the cell values in the column designation column become the column designations in the pivot table.

[0026] In some embodiments, the spreadsheet may include hidden rows. The hidden row is the row that is in the spreadsheet but not visible to the user of the spreadsheet application 108. The user may want to hide specific rows to simplify the presentation of the spreadsheet. In such embodiments, the sorting process sorts the hidden as well as visible rows in the spreadsheet.

[0027] Sorting rows in a spreadsheet comprises manipulating the order of the rows in the spreadsheet so that the rows in the spreadsheet are positioned in a predetermined manner. Rows in a spreadsheet are positioned in a predetermined manner when rows are arranged in a predetermined manner for each sorted column. A sort column is a column in a spreadsheet in which rows are sorted. In a column sorting operation, the columns in the spreadsheet are arranged in a predetermined manner, when the columns are arranged in a predetermined manner for each sorting row. The term "sort line" is used herein to refer usually to a sort column or sort line.

[0028] Each sorting column has sorting requirements. Sort requirements include the relevant property and order relation. A relevant property can be many different cell properties in a sort column. For example, a relevant property can be cell values, cell color, cell flags, font colors in cells, font styles in cells, font size in cells, hidden / visible cell status, and other cell properties.

[0029] An order relation is a collection of one or more rules that determine how properties are ordered. Exemplary types of order relationships include alphabetical order, reverse alphabetical order, numerical order, reverse numerical order, chronological order, reverse chronological order, categorical order, geographical order, and other types of tasks. As one specific example of a categorical order, the order relation can determine the order by Boolean values, indicating that all true values are before any false values. In another example, the order relation can determine the order by cell colors, indicating that blue cells are in front of green cells, yellow cells are in front of blue cells, red cells are in front of yellow cells, and so on. In some embodiments, the user of the spreadsheet application 108 is able to select sorting columns and sorting requirements for these sorting columns.

[0030] When there are multiple sorting columns, these sorting columns are ranked. The rows in the spreadsheet are sorted first in accordance with the sorting requirements of the highest sort column, then in accordance with the sorting requirements of the second, highest sort column, and so on. Therefore, the rows are arranged in the specified way for a given sorting column, when for any two rows that have the same relevant properties in the cells of each higher-ranking sorting column, these two rows satisfy the sorting requirements of a given sorting column. These two rows satisfy the sorting requirements of a given sorting column when the order relation for a given sorting column is kept true for the relevant property of these two cells.

[0031] As described in detail elsewhere in this document, spreadsheet application 108 divides rows in a spreadsheet into multiple blocks. A block is a set of strings. Therefore, a block can be thought of as a smaller spreadsheet. In some embodiments, the number of rows in each of the blocks is based on the number of rows in the spreadsheet and the number of processing blocks 110. For the most part, the number of blocks is equal to the number of processing blocks 110 in the processing system 104.

[0032] After the lines are divided into blocks, the sorting process enters the block sorting phase. During the block sorting phase, the spreadsheet application 108 uses multiple block sorting streams to sort rows in blocks. The number of block sort threads is equal to the number of blocks. Each of the block sort threads works to sort the rows in each of the blocks.

[0033] After the block sort streams sort the rows in the blocks, the sort process enters the merge (merge) phase. During the combining phase, the spreadsheet application 108 uses multiple combining streams to generate a block of the final result. The end result block contains each of the rows in the spreadsheet. The rows in the end result block are ordered in the specified way. Each of the union threads is a stream that combines the two source blocks to generate a result block. Each of the original blocks of the union stream may be either one of the sorted blocks generated by the block sort stream, or a result block generated by another union stream. For example, the source blocks of a merge stream can be sorted blocks generated by block sort streams. In another example, the source blocks of the union stream may be a sorted block generated by one of the block sort threads, and a result block generated by another union stream. In yet another example, the source blocks of a join stream may be result blocks generated by other join streams.

[0034] After the end result block is generated, the spreadsheet application 108 outputs the result data for presentation to the user of the spreadsheet application 108. The result data depends on the order of the rows in the end result block.

[0035] In various embodiments, the spreadsheet application 108 outputs various types of result data. For example, in some embodiments, the spreadsheet application 108 displays a sorted version of the spreadsheet in which the rows in the spreadsheet are ordered according to the row order in the end result block. In addition, in some embodiments, the spreadsheet application 108 generates and displays a message showing at least some rows in the end result block. In addition, in some embodiments, the result data optionally includes all rows in a spreadsheet. In cases where the result data is used by another process or the subsets of the spreadsheet are subject to further sorting, the result data is not necessarily presented to the user.

[0036] FIG. 2 is a block diagram illustrating an exemplary alternative embodiment of a computing system 100. As illustrated in the example of FIG. 2, the computing system 100 comprises a data storage system 102 and a processing system 104, as in the exemplary embodiment illustrated in FIG. 1. However, in contrast to the exemplary embodiment illustrated in FIG. 1, an exemplary alternative embodiment of a computing system 100 illustrated in FIG. 2, has a network interface 200 instead of a display system 106.

[0037] The network interface system 200 allows the computing system 100 to send and receive data from the client device 202 through the network 204. The network 204 is a communication system comprising computing devices and communication lines that facilitate communication between the computing system 100 and the client device 202. In various embodiments, network 204 includes various types of computing devices. For example, network 204 may include routers, switches, mobile access points, bridges, hubs, intrusion detection devices, storage devices, stand-alone servers, ultra-compact servers (blades), sensors, desktop computers, firewalls, laptops, laptop computers, mobile telephones and other types of computing devices. In various embodiments, network 204 includes various types of communication links. For example, network 204 may include wired and / or wireless links. In addition, in various embodiments, the network 204 is implemented at various scales. For example, network 204 may be implemented as one or more local area networks (LANs), metropolitan area networks, subnets, wide area networks (such as the Internet), or may be implemented on a different scale.

[0038] The client device 202 is a computing device. For example, client device 202 may be a personal computer used by a user. The user uses the client device 202 to send requests to the computer system 100 and receive information from the computer system 100 through the network 204. Thus, the user can use the client device 202 to view and manipulate tabular data by using the spreadsheet application 108. For example, the computing system 100 may send the result data to the client device 202 via the network 204. In this example, the client device 202 is configured to process the result data to display a sorted version of the spreadsheet to the user of the client device 202. For example, client device 202 may provide a web page containing result data, or interact with a client application to display result data.

[0039] FIG. 3 is a flowchart illustrating an example operation 300 for sorting a spreadsheet. As illustrated in the example of FIG. 3, operation 300 begins when the spreadsheet application 108 receives a sort command (302). The sort command instructs the spreadsheet application 108 to start the sort process in a particular spreadsheet. In addition, the sort command can set the relevant property, the sorted column in the spreadsheet, and the ordering relationship. In some embodiments, a user of a spreadsheet application 108 may select a spreadsheet, relevant property, sorted column, and / or ordering relationship.

[0040] In various embodiments, the spreadsheet application 108 receives a sort command in various ways. For example, in some embodiments, the spreadsheet application 108 receives a sort command when the user of the spreadsheet application selects a specific user control tool for the spreadsheet application 108. In addition, in some embodiments, the spreadsheet application 108 receives a sort command when a user enters a specific keyboard command. In addition, in some embodiments, the spreadsheet application 108 receives a sort command from another process, thread, or application running on computer system 100, client device 202, or another computing device.

[0041] In addition, in some embodiments, the spreadsheet application 108 starts an operation 300 without receiving an explicit sort command from a user or other process, thread, or application. For example, in some embodiments, a spreadsheet application 108 may start an operation 300 automatically on a periodic basis or based on a schedule. Furthermore, in some embodiments, the spreadsheet application 108 may start an operation 300 automatically when a user updates one or more rows in a spreadsheet. In addition, in some embodiments, the spreadsheet application 108 starts an operation 300 automatically in response to detecting or receiving an event indicating that a change has occurred in the data source from which the spreadsheet is derived.

[0042] In response to receiving a sort command or otherwise receiving an indication to start the sort process in the spreadsheet, the spreadsheet application 108 determines whether the total number of rows in the spreadsheet exceeds the lower limit (304). In various embodiments, the lower limit has different meanings. For example, in some embodiments, the lower limit is 255. In other embodiments, the lower limit is greater than 255 or less than 255. In some embodiments, the spreadsheet application 108 provides a user interface that allows an administrative user to set a lower limit. An administrative user can be a user who accepts result data, or another user.

[0043] If the number of rows in the spreadsheet does not exceed the lower limit ("NO" of 304), the spreadsheet application 108 uses a single stream to generate a block (306) of the final result. A single stream generates a block of the final result by sorting the rows in the spreadsheet so that the rows in the spreadsheet are ordered in the specified way. Using a single stream to sort rows can be more efficient than using multiple streams to sort rows when the number of rows in a spreadsheet is relatively small. The reason is that there may be computational fines (eg, delays) associated with the start or wake of the threads. Such computational fines can only adversely affect when there are enough lines.

[0044] If the number of rows in the spreadsheet exceeds the lower limit ("YES" of 304), the spreadsheet application 108 determines the appropriate number of blocks (308). In various embodiments, the spreadsheet application 108 determines the appropriate number of blocks in various ways. For example, in some embodiments, the minimum job size is the minimum number of lines in a block that needs to start a reasonable additional block sort stream. In some cases, the lower limit is equal to the minimum job size multiplied by two. In this example, if the number of rows in the spreadsheet divided by the minimum job size is less than or equal to the number of processing blocks 110 in the processing system 104, a suitable number of blocks is equal to the number of rows divided by the minimum job size rounded down. For example, if there are 300 lines, the minimum job size is 128, and there are eight processing blocks in the processing system 104, the corresponding number of blocks is two. If the number of rows in the spreadsheet divided by the minimum job size is greater than or equal to the number of processing blocks 110 in the processing system 104, the corresponding number of blocks is equal to the number of processing blocks 110. For example, if there are 30,000 rows, the minimum job size is 128, and there are eight processing blocks in the processing system 104, the corresponding number of blocks is eight. In some embodiments, the spreadsheet application 108 provides a user interface that allows an administrative user to set a minimum job size.

[0045] Then, the spreadsheet application 108 divides the rows in the spreadsheet into a set of blocks (310). The number of blocks in the set of blocks is equal to the corresponding number of blocks. Each block in a block set contains approximately the same number of rows.

[0046] In various embodiments, blocks are implemented in various ways. For example, in some embodiments, the blocks are implemented as a data structure that contains row identifiers (for example, row "513", row "234", row "876", etc.). In such embodiments, inserting rows into a block comprises inserting row identifiers into a block, and sorting rows in a block comprises rearranging row identifiers in a block. In other embodiments, blocks are data structures containing copies of strings.

[0047] After dividing the rows into blocks, the spreadsheet application 108 begins the sorting phase of the block of the sorting process. During the block sorting phase of the sorting process, the spreadsheet application 108 uses multiple block sorting streams to sort rows in blocks (312). The number of block sort threads in a set of block sort threads is equal to the number of blocks in a block set. For example, if the number of blocks is eight, the number of block sort threads is eight. In some cases, each block sort stream is executed in parallel in a different one of the processing blocks 110 in the processing system 104. Spreadsheet application 108 assigns one of the blocks to each of the block sort streams. Block sort threads sort lines in blocks assigned to block sort threads. In various embodiments, block sort streams use different algorithms to sort rows in blocks. For example, in various embodiments, the block sort flows use a quick sort algorithm (e.g., qsort), a bubble sort algorithm, a merge (merge) sort algorithm, or another sort algorithm to sort rows in blocks.

[0048] At some time after the spreadsheet application 108 wakes up a set of block sort threads, the spreadsheet application 108 determines that the block sort threads have finished sorting each of the blocks (314). In various embodiments, spreadsheet application 108 determines that block sort streams have finished sorting each of the blocks in various ways. For example, in some embodiments, the block sort streams provide completion indicators to the spreadsheet application 108 when the block sort streams have finished sorting the blocks. In other embodiments, block sort streams store sorted blocks in a buffer. In such embodiments, the spreadsheet application 108 determines that the block sort streams have finished sorting the blocks when the buffer contains a sorted version of each of the blocks.

[0049] After the block sort threads have finished sorting the blocks, the sort phase of the block of the sort process ends and the combining phase of the sort process begins. During the merge phase of the sorting process, the spreadsheet application 108 generates a stream tree (316). A flow tree is a binary tree in which each level, except possibly the last level, is completely populated. A binary tree is a tree data structure in which each node has at most two child nodes.

[0050] The number of merge threads in the thread tree is equal to the number of blocks minus one. A leaf stream is a union stream that does not have child streams in the stream tree. An internal thread is a union thread that has one or more child threads in a thread tree. An incomplete internal thread is an internal thread that has only one child thread in the thread tree. A full internal thread is an internal thread that has two child threads in the thread tree. The root thread is a union thread that does not have parent threads in the thread tree.

[0051] As described elsewhere in this document, the leaf stream functions to combine (merge) the sorted blocks assigned to the leaf stream, thereby generating a result block. The result block contains each of the rows in the assigned blocks. The rows in the result block are ordered in the specified way. An incomplete internal thread functions to combine result blocks generated by its only child process with a sorted block assigned to an incomplete internal thread. A full internal thread functions to combine the result blocks generated by its child threads into large result blocks. Ultimately, the root thread generates a block of the final result.

[0052] In various embodiments, the spreadsheet application 108 performs various actions to generate a stream tree. For example, in some embodiments, a spreadsheet application 108 generates a stream tree by first identifying available pooling threads and / or illustrating pooling threads. In this example, the spreadsheet application 108 then generates a pointer data structure that contains an element for each join stream. An element for a union stream specifies the source and destination element pointers. The source pointers specify memory locations that store the blocks that the join stream should combine. The destination element pointer specifies the location of the memory where the join stream should save the result block generated by the join stream. The pointer data structure may be a variety of different types of data structures, including sets, linked lists, vectors, tables, and so on.

[0053] After generating the stream tree, or as part of the generation of the stream tree, the spreadsheet application 108 assigns two of the blocks to each leaf stream in the stream tree (318). In various embodiments, the spreadsheet application 108 assigns blocks to sheet streams in various ways. For example, in embodiments that use the pointer data structure described above, the spreadsheet application 108 assigns a block to a sheet stream by issuing an initial pointer to a block memory location in the element for the sheet stream. In another example, the spreadsheet application 108 assigns a block to a leaf stream, giving the block identifier to the leaf stream as a parameter.

[0054] In addition, the spreadsheet application 108 determines whether there is an odd number of blocks (320). If there is an odd number of blocks, the thread tree contains an incomplete internal thread. Therefore, if there is an odd number of blocks ("YES" 320), the spreadsheet application 108 assigns one of the blocks to an incomplete internal stream (322).

[0055] After assigning blocks to an incomplete internal stream or determining that there are no odd number of blocks ("NO" 320), spreadsheet application 108 uses join streams to generate block (324) of the final result. To use join streams to generate an end result block, spreadsheet application 108 awakens join streams. In various embodiments, the spreadsheet application 108 awakens join streams in various ways. For example, in some embodiments, the spreadsheet application 108 awakens the pool threads by providing a wake event to the pool thread. In other embodiments, the spreadsheet application 108 runs one or more operating system interface methods to wake up the pool stream.

[0056] Then, the spreadsheet application 108 receives an indication of completion from the root stream in the stream tree (326). A completion indication indicates that the root thread has finished generating the end result block. The end result block contains all the rows in the spreadsheet. The rows in the end result block are ordered in the specified way.

[0057] After the spreadsheet application 108 receives the completion indication from the root stream, or after the rows are sorted in step 306, the spreadsheet application 108 returns a final result block (328). Then, the spreadsheet application 108 may provide result data that depends on the end result block.

[0058] FIG. 4 is a diagram showing an example tree 400 of streams. As illustrated in the example of FIG. 4, stream tree 400 contains stream 402, stream 404, stream 407, stream 408, stream 410, and stream 412. Stream 402, stream 404, and stream 406 are internal streams. Stream 402 and stream 404 are complete internal streams. Stream 406 is an incomplete internal stream. Stream 408, stream 410, and stream 412 are leaf streams.

[0059] In addition, an example of FIG. 4 shows that blocks 414 and 416 are assigned to stream 408, that blocks 418 and 420 are assigned to stream 410, that blocks 422 and 424 are assigned to stream 412, and that block 426 is assigned to stream 406. In other words, blocks 418 and 420 are source blocks of stream 408. Blocks 418 and 420 are source blocks of stream 410. Blocks 422 and 424 are source blocks of stream 412. Block 426 is a source block of stream 406.

[0060] Stream 408 combines blocks 414 and 416 to generate a result block. Stream 410 combines blocks 418 and 420 to generate a result block. Stream 412 combines blocks 422 and 424 to generate a result block. Thread 404 combines the result blocks generated by threads 408 and 410 to generate a result block. In other words, the result blocks generated by streams 408 and 410 are the original blocks of stream 404. Stream 406 combines the blocks 426 and the result block generated by stream 412 to generate a result block. In other words, the result block generated by stream 412 is the original block of stream 406. Stream 402 combines the result blocks generated by streams 404 and 406 to generate a block of the final result. In other words, the result blocks generated by streams 404 and 406 are the original blocks of stream 402.

[0061] FIG. 5 is a flowchart illustrating an exemplary operation 500 performed by a leaf stream during a combining phase of a sorting process. Although operation 500 is explained with respect to a single leaf stream, each leaf stream in the stream tree can perform operation 500. As illustrated in the example of FIG. 5, operation 500 begins when a sheet stream is awakened by a spreadsheet application 108 (502). Awakening a thread is the process of preparing a thread for launch. In various embodiments, the spreadsheet application 108 awakens a sheet stream in various ways. For example, in some embodiments, the spreadsheet application 108 maintains links to sleep threads that are able to perform operation 500. In some embodiments, sleep sleep flows may include block sort threads used in the sort phase of the block sort process. In other words, one of the block sorting streams can act as a leaf stream. To wake up a leaf stream, the spreadsheet application 108 outputs a wake up event to a stream that can perform an operation 500 and provides the leaf stream with a link to the first block assigned to this leaf stream and the second block assigned to this leaf stream.

[0062] After the leaf stream wakes up, this leaf stream determines whether the largest row in the first block is less than the smallest row in the second block (504). Since the rows in the first block are ordered in the specified way, the largest row in the first block is the last row in the first block. Since the rows in the second block are ordered in the specified way, the smallest row in the second block is the first row in the second block. If the leaf stream determines that the largest row in the first block is smaller than the smallest row in the second block, there is no overlap between the first block and the second block, and there is no need to compare the individual rows in the first block and the second block. Instead, if the leaf stream determines that the largest row in the first block is less than the smallest row in the second block (“YES” 504), the leaf stream inserts the first block at the lower end of the result block and inserts the second block at the larger end of the result block ( 506). Thus, the result block contains all the rows in the first block and the second block, and the rows in the result block are ordered in the specified way.

[0063] If the leaf stream determines that the largest row in the first block is not less than the smallest row in the second block, the leaf stream determines whether the largest row in the second block is smaller than the smallest row in the first block (508). Since the rows in the second block are ordered in the specified way, the largest row in the second block is the last row in the second block. Since the rows in the first block are ordered in the specified way, the smallest row in the first block is the first row in the first block. If the leaf stream determines that the largest row in the second block is smaller than the smallest row in the first block (“YES” 508), the leaf stream inserts the second block at the lower end of the result block and inserts the first block at the larger end of the result block (510). Thus, the result block contains all the rows in the first block and the second block, and the rows in the result block are ordered in the specified way.

[0064] If the largest row in the first block is larger than the smallest row of the second block and the largest row in the second block is larger than the smallest row in the first block, there is some overlap between the first block and the second block. If the leaf stream determines that the largest row in the second block is not less than the smallest row in the first block (“NO” 508), the leaf stream determines whether there are any remaining rows in the first block (512). A row is the remaining row when the row is no longer in the result block.

[0065] If there are one or more remaining rows in the first block ("YES" 512), the leaf stream determines whether there are any remaining rows in the second block (514). If there are no remaining rows in the second block, the leaf stream has already inserted all the rows in the second block into the result block. Therefore, if there are no remaining rows in the second block (“NO” 514), the sheet stream inserts any remaining rows in the first block into the result block after the largest row in the result block (518). After inserting the remaining rows in the first block into the result block, the result block contains all the rows in the first block and the second block, and the rows in the result block are ordered in the specified way.

[0066] If there is one or more remaining rows in the second block ("YES" 514), the leaf stream identifies the minimum row (516). The smallest row is the smallest of the remaining rows in the first block and second block.

[0067] As discussed above, in some embodiments, multiple sorting columns may be selected. For example, the user may indicate that the spreadsheet must first be sorted by the column "city" and then by the column "date". If there are many sorting columns, and if the relevant properties in the cells in the highest ranked two-row sorting column are the same, the minimum merge stream identifies the minimum row by comparing the relevant properties in the cells in the next highest ranking sorting column of these two rows. If the relevant properties of the cells in the next highest sort column are the same, the minimum join stream identifies the minimum row by comparing the relevant properties in the cells of the third, highest ranking column of the two columns. This comparison process continues until there is no sort column left, or until the minimum join stream identifies one of the rows that is smaller than the other row. If the relevant properties of the cells in all the sorting columns of these two rows are equal, the minimum join stream can identify any of the rows as the minimum row.

[0068] The leaf stream inserts the minimum row in the result block after the largest row in the result block (520). After inserting the minimum row in the result block, the leaf stream again determines if there are any remaining rows in the first block (512), and so on.

[0069] If there are no remaining rows in the first block, the leaf stream has already inserted all the rows in the first block into the result block. Therefore, if there are no remaining rows in the first block ("NO" 512), the leaf stream inserts any remaining rows in the second block into the result block after the largest row in the result block (514). After inserting the remaining rows in the second block into the result block, the result block contains all the rows in the first block and second block, and the rows in the result block are ordered in the specified way.

[0070] After performing any of steps 506, 510, 518 or 522, the leaf stream determines whether the leaf stream is the root stream (524). If the leaf stream is the root stream ("YES" 524), the leaf stream gives an indication of completion of the spreadsheet application 108 (526). A completion indication indicates that the leaf stream has completed the merging of the first block and the second block. If the leaf stream is not a root stream ("NO" 524), the leaf stream gives an indication of completion to the parent stream of the leaf stream (528). After either proving the completion indication to the spreadsheet application or the parent sheet stream, the sheet stream (530) goes into sleep mode.

[0071] FIG. 6 is a flowchart illustrating an example operation 600 performed by an incomplete internal thread. Operation 600 begins when an incomplete internal thread is awakened by spreadsheet application 108 (602). Spreadsheet application 108 provides a link to the first block and second block to an incomplete internal stream. The first block is the result block generated by the child thread of an incomplete internal thread. The second block is a block that was produced by one of the block sort threads during the sort phase of the block of the sort process. The incomplete internal thread and the child thread operate simultaneously on different threads of the processing units 110. Therefore, the child stream generates the first block, while the incomplete internal stream performs the operation 600. As a result, there may be cases where there are no remaining rows in the first block, but the child stream may later insert more rows into the first block.

[0072] After waking up, an incomplete internal thread determines whether there are any remaining rows in the first block (604). If there are one or more remaining lines in the first block (“YES” 604), the incomplete internal stream determines whether there are any remaining lines in the second block (606).

[0073] If there are no remaining rows in the second block ("NO" 606), the incomplete internal thread inserts any remaining rows in the first block into the result block after the largest row in the result block (608). Since the child thread generates the first block, while the incomplete internal thread performs operation 600, the child thread can add rows to the first block, while the incomplete internal thread performs operation 600. The incomplete internal thread is not guaranteed that the child thread will not add additional rows to the first block until the child thread provides an indication of completion to an incomplete internal thread. Therefore, after the incomplete internal thread inserts the remaining rows in the first block into the result block, the incomplete internal thread again determines whether there are any remaining rows in the first block (604), and so on.

[0074] If there is one or more remaining lines in the second block ("YES" 606), an incomplete internal stream identifies the minimum line (610). The smallest row is the smallest remaining row in either the first block or the second block. The incomplete internal thread then inserts the minimum row in the result block after the largest row in the result block (612). After inserting the minimum row in the result block, the incomplete internal stream again determines whether there are any remaining rows in the first block (604), and so on.

[0075] If there are no remaining lines in the first block ("NO" 612), the incomplete internal thread determines whether the child thread is executed (614). The child thread is executed when the child thread provides an indication of completion to an incomplete internal thread. If the child thread has not yet been executed, the child thread may still continue to insert rows in the first block. Therefore, if the child thread is not executed ("NO" 614), an incomplete internal thread is waiting (616). In various embodiments, an incomplete internal stream waits until various events occur. For example, in some embodiments, an incomplete internal thread waits until the timer expires. In other embodiments, an incomplete internal stream waits until a final event occurs. The resulting event may be an insertion of a row in the first block, an indication of completion from the child thread, or another type of event. After the incomplete internal thread completes the wait, the incomplete internal thread again determines if there are any remaining rows in the first block (604), and so on.

[0076] If the child thread is executed ("YES" 614), the incomplete internal thread inserts any remaining rows in the second block into the result block after the largest row in the result block (618). If there are no remaining rows in the second block when the child thread is executed, the incomplete internal thread does not insert rows into the result block in step 618.

[0077] After inserting the remaining rows in the second block into the result block, the incomplete internal stream determines whether the incomplete internal stream is the root stream (620). If the incomplete internal stream is the root stream ("YES" 620), the incomplete internal stream provides an indication of completion of the spreadsheet application 108 (622). If the incomplete internal stream is not a root stream ("NO" 620), the incomplete internal stream gives an indication of completion to the parent stream of the incomplete internal stream (624). After or issuing the completion indication to the spreadsheet application 108 or to the parent stream, the incomplete internal stream goes into sleep mode (626).

[0078] FIG. 7 is a flowchart illustrating an example operation 700 performed by a complete internal thread. Although operation 700 is explained with respect to a single complete internal stream, each complete internal stream in the stream tree may perform operation 700. As illustrated in the example of FIG. 7, operation 700 begins when a full internal stream is awakened by spreadsheet application 108 (702). Spreadsheet application 108 provides a link to the first block and second block to the full internal stream. The first block is the result block generated by the first child stream of the full internal stream. The second block is the result block generated by the second child stream of the full internal stream. The full internal stream, the first child stream and the second child stream operate simultaneously on different threads of processing units 110. Therefore, the first child stream generates the first block, and the second child stream generates the second block, while the full internal stream performs operation 700. In addition, since the full internal stream and the first child stream work simultaneously, there may be situations when the first block does not contain any remaining rows, but the first child stream may later insert more rows into the first block. Similarly, since the full inner stream and the second child stream work simultaneously, there may be situations where the second block does not contain the remaining rows, but the second child stream may later insert more rows into the second block.

[0079] After waking up, the full internal thread determines if there are any remaining lines in the first block (704). If the total internal stream determines that there is one or more remaining lines in the first block (“YES” 704), the full internal stream determines whether there are any remaining lines in the second block (706).

[0080] If there are no remaining rows in the second data block ("NO" 706), the full internal stream determines whether the second child stream (708) has been executed. The second child thread is executed if the second child thread gives an indication of completion in the full internal thread. If the second child stream is not executed, the second child stream may insert additional rows in the second block. Some of these lines may be smaller than the smallest line in the first block. Therefore, if the full internal thread determines that the second child thread has not completed ("NO" 708), the full internal thread is waiting (710). In various embodiments, a complete internal stream waits until various events occur. For example, in some embodiments, a complete internal thread waits until a timer expires. In other embodiments, the full internal stream waits until the full internal stream receives the resulting event. The resulting event may indicate that the second thread inserted a row in the second block or that the second thread has completed. After the full internal thread has finished waiting, the full internal thread will again determine if the second block includes any rows (706) and so on.

[0081] If the second child stream is executed, then the second child stream will not insert more rows in the second block and there are no remaining rows in the second block. Therefore, all remaining lines in the first block are larger than any line in the result block. Therefore, if the full internal stream determines that the second child stream has been executed ("YES" 708), the full internal stream inserts any remaining rows in the first block into the result block after the largest row in the result block (712). After inserting the remaining lines in the first block into the result block, the full internal stream re-determines whether there are any remaining lines in the first block (704) and so on.

[0082] If the total internal stream determines that there is a remaining line in the second block ("YES" 706), the full internal stream identifies the minimum line (714). The smallest row is the smallest remaining row in either the first block or the second block. The full internal stream then inserts the minimum row in the result block after the largest row in the result block (716). After inserting the minimum row in the result block, the full internal stream re-determines whether there are any remaining rows in the first block (704), and so on.

[0083] If there are no remaining lines in the first block ("NO" 704), the full internal thread determines whether the first child thread (718) is executed. The first child thread is executed when the first child thread gives an indication of completion to the full internal thread. If the first child thread has not yet completed, the first child thread may continue to insert rows in the first block. Therefore, if the first child thread is not executed ("NO" 718), the full internal thread is waiting (720). In various embodiments, a complete internal stream waits until various events occur. For example, in some embodiments, a full internal thread waits until the timer expires. In other embodiments, a complete internal stream waits until a final event occurs. The resulting event may be an insertion of a row into the first block, an indication of completion from the first child stream, or another type of event.

[0084] If the first child thread is executed ("YES" 718), the full internal thread determines if there are any remaining rows in the second block (722). If there is one or more remaining rows in the second block ("YES" 722), the full internal stream inserts any remaining rows in the second block into the result block after the largest row in the result block (724). A full internal thread can insert the remaining rows in the second block into the result block, since the first child stream will not add more rows to the first block, and all rows in the first block were added to the result block. Therefore, any remaining lines in the second block are larger than the largest line in the result block.

[0085] After inserting any remaining rows in the second block into the result block or after determining that there are no remaining rows in the second block ("NO" 722), the full internal stream determines whether the second child stream (726) has been executed. If the full internal thread determines that the second thread has not completed ("NO" 712), the full internal thread is waiting (728). After the full internal thread completes the wait, the full internal thread again determines if there are any remaining rows in the second block (722) and so on.

[0086] If the full internal stream determines that the second child stream has completed ("YES" 726), the full internal stream determines whether the full internal stream is the root stream (730). If the full internal stream is the root stream ("YES" 730), the full internal stream gives an indication of completion of the spreadsheet application 108 (732). If the full internal thread is not the root thread ("NO" 730), the full internal thread gives an indication of completion to the parent thread of the full internal thread (734). After either issuing the completion indication to the application, the spreadsheet 108 or the parent stream of the full internal stream, the full internal stream goes into sleep mode (736).

[0087] FIG. 8 is a flowchart illustrating an exemplary operation 800 performed by a memory control flow during a process combining phase. Some embodiments use a memory management method that includes two buffers. In such embodiments, each of the sorted blocks generated during the block sorting phase is stored in a first buffer. For example, blocks 414, 416, 418, 420, 422, 424 and 426, illustrated in the example of FIG. 4 are stored in the first buffer. When leaf streams generate result blocks, these leaf streams are read from the first buffer and store their result blocks in a second buffer. For example, streams 408, 410, and 412 illustrated in the example of FIG. 4, save their result blocks in a second buffer. Internal streams in the first level above leaf streams read lines from the second buffer and save their result blocks back to the first buffer. For example, streams 404 and 406 illustrated in the example of FIG. 4, read from the second buffer and store their result blocks in the first buffer. Internal streams in the second level above the leaf streams read the rows from the first buffer, and the result blocks are saved back to the second buffer. For example, stream 402 illustrated in the example of FIG. 4, reads from the first buffer and stores its result blocks in the second buffer. This continues for progressively higher levels in the stream hierarchy. In some circumstances, this memory management method may be more efficient than allocating memory blocks for individual result blocks.

[0088] In some embodiments using this memory management method, the spreadsheet application 108 waits for the end result block to be in the first buffer. However, in some cases, the end result block is in the second buffer, and not in the first buffer. In addition, in some embodiments using this memory management method, all merge threads at a given level wait for reads from the same buffer and store the result blocks in the same buffer. However, an incomplete internal stream reads the block produced by leaf flows (i.e., the block in the second buffer) and the block generated during the block sorting phase (i.e., the block in the first buffer). The memory management thread performs operation 800 to fix these problems.

[0089] As illustrated in the example of FIG. 8, operation 800 begins when a memory management thread is awakened by a spreadsheet application (802). Upon waking up, the memory control flow determines whether there is an odd number of sorted blocks generated during the sorting phase of the sorting process block (804). If there is an odd number of blocks in the first buffer, the thread hierarchy includes an incomplete internal thread. Therefore, if there is an odd number of blocks in the first buffer (“YES” 804), the memory control stream copies to the second buffer the block assigned to the incomplete internal stream (806). Thus, the block is ready for use by an incomplete internal stream.

[0090] After copying a block to a second buffer or after determining that there are no odd number of blocks generated in the sort phase of the block of the sorting process ("NO" 804), the memory control flow determines whether the block of the final result is complete (808). If the end result block is not complete ("NO" 808), the memory control thread is waiting (810). In various embodiments, a memory control flow waits until various events occur. For example, in some embodiments, the memory management thread waits until the timer expires. In other embodiments, a memory management thread waits until the root thread provides an indication of completion of the spreadsheet application 108. After the memory management thread completes the wait, the memory management thread again determines whether the end result block is complete (808).

[0091] If the end result block is completed ("YES" 808), the memory control flow determines whether the end result block is in the second buffer (812). If the end result block is in the second buffer ("YES" 812), the memory management thread copies the end result block to the first buffer (814). After copying the block of the final result into the first buffer or after determining that the block of the final result is already in the first buffer ("NO" 812), the memory control stream (816) goes into sleep mode.

[0092] FIG. 9 is a block diagram illustrating an example computing device 900. In some embodiments, computing system 100 is implemented using one or more computing devices, such as computing device 900. It should be appreciated that in other embodiments, computing system 100 is implemented using computing devices having hardware components other than those illustrated in the example of FIG. 9.

[0093] In various embodiments, computing devices are implemented in different ways. For example, in the example of FIG. 9, computing device 900 comprises a memory 902, a processing system 904, a secondary storage device 906, a network interface card 908, a video interface 910, a display device 912, an external component interface 914, an external storage device 916, an input device 918, a printer 920, and communication medium 922. In other embodiments, computing devices are implemented using more or less hardware components. For example, in another exemplary embodiment, the computing device does not include a video interface, a display device, an external storage device, or an input device.

[0094] Memory 902 includes one or more computer-readable storage media capable of storing data and / or instructions. As used in this document, a computer-readable storage medium is a device or manufacturing product that stores data and / or software instructions read by a computing device. In various embodiments, memory 902 is implemented in different ways. For example, in various embodiments, memory 902 is implemented using various types of computer-readable storage media. Exemplary types of computer-readable storage media include, but are not limited to, dynamic random access memory (DRAM), dual-speed synchronous dynamic random access memory (DDR SDRAM), reduced latency DRAM, DDR2 SDRAM, DDR3 SDRAM, RAM Rambus, semiconductor memory, flash memory, read-only memory (ROM), electrically erasable programmable ROM and other types of devices and / or manufacturing products that store data.

[0095] The processing system 904 includes one or more physical integrated circuits that selectively execute software instructions. In various embodiments, the processing system 904 is implemented in various ways. For example, in one exemplary embodiment, the processing system 904 is implemented as one or more processing cores. For example, in this exemplary embodiment, the processing system 904 may be implemented as one or more Intel Core 2 microprocessors. In another exemplary embodiment, the processing system 904 is implemented as one or more separate microprocessors. In yet another exemplary embodiment, the processing system 904 is implemented as an ASIC that provides special functionality. In yet another exemplary embodiment, processing system 904 provides special functionality when using ASICs and through executing software instructions.

[0096] In various embodiments, the processing system 904 executes software instructions in various instruction sets. For example, in various embodiments, the processing system 904 executes software instructions in instruction sets, such as the x86 instruction set, the POWER instruction set, the RISC instruction set, the SPARC instruction set, the IA-64 instruction set, the MIPS instruction set, and / or other instruction sets .

[0097] The secondary storage device 906 includes one or more computer-readable storage media. Secondary storage device 906 stores data and software instructions not directly available to processing system 904. In other words, the processing system 904 performs an input / output operation for retrieving data and / or software instructions from the secondary storage device 906. In various embodiments, the secondary storage device 906 is implemented by various types of computer-readable storage media. For example, secondary storage device 906 may be implemented with one or more magnetic disks, tape devices, CD-ROMs, DVD ROMs, Blu-ray discs, semiconductor memory devices, Bernoulli drives, and / or other types of computer-readable storage media.

[0098] The network interface card 908 allows the computing device 900 to send data and receive data from a computer communication network. In various embodiments, the network interface card 908 is implemented in different ways. For example, in various embodiments, the network interface card 908 is implemented as an Ethernet interface, a token ring network, a fiber optic network interface, a wireless network interface (e.g., WiFi, WiMax, etc.) or another type of network interface.

[0099] Video interface 910 allows computing device 900 to output video information to display device 912. In various embodiments, the video interface 910 is implemented in different ways. For example, in one exemplary embodiment, the video interface 910 is integrated into the motherboard of the computing device 900. In another exemplary embodiment, the video interface 910 is an expansion video card. Exemplary types of expansion video cards include Radeon graphics cards manufactured by ATI Technologies, Inc Markham, Ontario, Geforce graphics cards manufactured by Nvidia Corporation, Santa Clara, California, and other types of graphics cards.

[0100] In various embodiments, the display device 912 is implemented as various types of display devices. Exemplary types of display devices include, but are not limited to, cathode ray tube displays, LCD display panels, touch-sensitive plasma display panels, LED screens, projectors, and other types of display devices. In various embodiments, the video interface 910 communicates with the display device 912 in various ways. For example, in various embodiments, the video interface 910 communicates with the display device 912 via a universal serial bus (USB) connector, a VGA connector, a digital visual interface (DVI) connector, an S-video connector, a high-resolution multimedia interface (HDMI) connector, a DisplayPort connector or other types of connectors.

[0101] The external component interface 914 allows the computing device 900 to communicate with external devices. In various embodiments, the external component interface 914 is implemented differently. For example, in one exemplary embodiment, the external component interface 914 is a USB interface. In other exemplary embodiments, the computing device 900 is a FireWire interface, a serial port interface, a parallel port interface, a PS / 2 interface, and / or another type of interface that allows the computing device 900 to communicate with external components.

[0102] In various embodiments, the external component interface 914 allows the computing device 900 to communicate with various external components. For example, in the example of FIG. 9, an external component interface 914 allows the computing device 900 to communicate with an external storage device 916, an input device 918, and a printer 920. In other embodiments, the external component interface 914 allows the computing device 900 to communicate with more or fewer external components. Other exemplary types of external components include, but are not limited to, speakers, phone jacks, modems, media player installation modules, other computing devices, scanners, digital cameras, fingerprint readers, and other devices that may be associated with computing device 900.

[0103] The external storage device 916 is an external component comprising one or more computer-readable storage media. Various implementations of computing device 900 are associated with various types of external storage devices. Exemplary types of external storage devices include, but are not limited to, magnetic tape devices, flash memory modules, magnetic drives, optical drives, flash memory blocks, zip drives, optical music players, and other types of devices containing one or more computer readable storage media. Input device 918 is an external component that provides user input to computing device 900. Various implementations of computing device 900 are associated with various types of input devices. Exemplary types of input devices include, but are not limited to, keyboards, mice, trackballs, stylus input devices, keyboards, microphones, joysticks, touch-sensitive displays, and other types of devices that provide user input to computing device 900. Printer 920 is an external device that prints data on paper. Various implementations of computing device 900 are associated with various types of printers. Exemplary types of printers include, but are not limited to, laser printers, inkjet printers, photo printers, copy machines, fax machines, receipt printers, dot matrix printers or other types of devices that print data on paper.

[0104] Communication medium 922 provides communication between hardware components of computing device 900. In various embodiments, communication medium 922 provides communication between various components of computing device 900. For example, in the example of FIG. 9, a communication medium 922 facilitates communication between a memory 902, a processing system 904, a secondary storage device 906, a network interface card 908, a video interface 910, and an external component interface 914. In various implementations of computing device 900, communication medium 922 is implemented in different ways. For example, in various implementations of computing device 900, communication medium 922 may be implemented as a PCI bus, PCI Express bus, accelerated graphic port (AGP) bus, Infiniband connecting wire, interface connecting cable for connecting external devices, ATA interface connecting cable ATA parallel, fiber-optic patch cord, USB bus, small computer system interface (SCSI), or other type of communication medium.

[0105] Memory 902 stores various types of data and / or software instructions. For example, in the example of FIG. 9, a memory 902 stores a basic input / output system (BIOS) 924, an operating system 926, application software 928, and program data 930. BIOS 924 includes a set of software instructions that, when executed by processing system 904, forces computing device 900 to boot for operation. Operating system 926 includes a set of software instructions that, when executed by processing system 904, forces computing device 900 to provide an operating system that coordinates the activities and sharing of resources of computing device 900. Types of example operating systems include, but are not limited to, Windows Microsoft (R), Linux, Unix, Apple OS X, Apple OS X iPhone, Palm webOS, Palm OS, Google Chrome OS, Google Android OS and so on. The application software 928 includes a set of software instructions that, when executed by the processing system 904, forces the computing device 900 to provide applications to the user of the computing device 900. The program data 930 is data generated and / or used by the application software 928.

[0106] The various embodiments described above are provided by way of illustration only and should not be construed as limiting. Specialists in the art will easily recognize various modifications and changes that can be applied without the following exemplary embodiments and applications, illustrated and described in the present description. For example, the operations shown in the drawings are merely examples. In various embodiments, such operations may include more or fewer steps than shown in the drawings. In addition, in other embodiments, similar operations may include the steps of operations shown in the drawings in a different order.

Claims (15)

1. A method for sorting data in a spreadsheet, comprising:
division of data elements in a spreadsheet into many blocks;
using multiple streams to sort data items in said blocks;
after sorting the data elements in the blocks, using a computer system, a plurality of combining streams to generate a block of the final result, and the final result block contains each of the data elements in the spreadsheet, each of the combining streams is a stream that combines two source blocks to generate a block of the result, each from the source blocks is either one of the sorted blocks, or one of the result blocks generated by another union stream; and
displaying a sorted version of the spreadsheet, wherein the data elements in the sorted version of the spreadsheet are ordered according to the order of the data elements in the end result block. 2. The method of claim 1, further comprising: determining a suitable number of blocks based on the minimum job size and the number of processing blocks in the processing system,
in which the number of blocks in said plurality of blocks is equal to said suitable number of blocks, and
in which the number of data elements in each of the blocks is approximately equal. 3. The method of claim 1, further comprising:
determining by means of a computing system whether the number of data elements in the spreadsheet exceeds the lower limit; and
using a single stream to generate a block of the final result when the number of data elements in the spreadsheet does not exceed the lower limit. 4. The method according to p. 1,
wherein one of the combining streams is an incomplete internal stream when the number of blocks in the plurality of blocks is odd;
in which the method further comprises assigning one of the blocks to an incomplete internal stream; and
in which the result block generated by the incomplete internal stream contains each of the data elements in the result block generated by the child stream of the incomplete internal stream and the block assigned to the incomplete internal stream, wherein the data elements in the result block generated by the incomplete internal stream are ordered in the specified way . 5. The method according to p. 4, in which the incomplete internal stream performs at least the following actions:
determining whether there are any remaining data items in the first block, the first block being a result block generated by a child stream of an incomplete internal stream;
performing the following actions when there is one or more remaining data elements in the first block:
determining if there are any remaining data items in the second block, the second block being allocated to an incomplete internal stream;
performing the following actions when there is one or more remaining data elements in the second block:
identification of the minimum data element, the minimum data element being the smallest of the remaining data elements in the first block and second block; inserting a minimum data element in the result block after the largest data element in the result block generated by an incomplete internal stream; and inserting, when there are no remaining data elements in the second block, any remaining data elements in the first block, into the result block generated by the incomplete internal stream after the largest data element in the result block generated by the incomplete internal stream;
determining when there are no remaining data elements in the second block, whether the child thread is executed;
Waiting for the child thread to fail until the child thread adds another data item to the second block; and
insert, when the child stream is executed, any remaining data elements in the second block into the result block generated by the incomplete internal stream, after the largest data element in the result block generated by the incomplete internal stream. 6. The method of claim 1, wherein the combining streams include a parent thread that begins to generate a result block before the child streams of the parent thread finish generating their result blocks, the child streams of the parent stream being different from the combining streams. 7. The method of claim 1, wherein the combining streams include a leaf stream that performs the following actions:
determining whether there are any remaining data items in the first block assigned to the sheet stream, the first block being one of the sorted blocks;
performing the following actions when there is one or more data elements in the first block:
determining if there are any remaining data items in the second block assigned to the sheet stream, the second block being another one of the sorted blocks;
performing the following actions when there is one or more data elements in the second block:
identification of the minimum data element, the minimum data element being the smallest of the remaining data elements in the first block and the second block, and inserting the minimum data element into the result block generated by the leaf stream after the largest data element in the result block;
insertion, when there are no remaining data elements in the second block, any remaining data elements in the first block in the result block generated by the sheet stream, after the largest data element in the result block generated by the sheet stream; and
insert, when there are no remaining data elements in the first block, any remaining data elements in the second block in the result block after the largest data element in the result block generated by the sheet stream. 8. The method according to p. 7, in which the sheet stream performs the following actions in response to awakening:
determining whether the largest data element in the first block is smaller than the smallest data element in the second block;
performing when the largest data element in the first block is smaller than the smallest data element in the second block of at least the following actions without comparing additional data elements in the first block and second block:
inserting data elements in the first block into the result block generated by the sheet stream; and inserting data elements in the second block into the result block after the largest data element in the result block is generated by the leaf stream;
determining whether the largest data element in the second block is smaller than the smallest data element in the first block; and
performing when the largest data element in the second block is smaller than the smallest data element in the first block of at least the following actions without comparing additional data elements in the first block and second block:
inserting data elements in the second block into the result block generated by the sheet stream, and inserting data elements in the first block into the result block after the largest data element in the result block generated by the sheet stream. 9. The method of claim 1, wherein the spreadsheet is a pivot table. 10. A computing system for sorting data in a spreadsheet, containing:
a processing system comprising a plurality of processing units; and a data storage system comprising computer-readable instructions that, when executed by one or more processing units, force the computing system:
Separate data elements in a spreadsheet into multiple blocks
use multiple flows of sorting blocks to sort data elements in blocks in which the number of flows of sorting blocks is equal to the number of blocks;
after the data elements in the blocks are sorted, use multiple join streams to generate the final result block, with the final result block containing each of the data elements in the spreadsheet, each of the join flows is a stream that combines the two source blocks to generate the result block, each from the source blocks is either one of the sorted blocks or one of the result blocks generated by another union stream; and
display a sorted version of the spreadsheet, and the data elements in the sorted version of the spreadsheet are ordered in accordance with the order of the data elements in the end result block. 11. The computing system of claim 10, wherein the computer-readable instructions, when executed by one or more processing units, force the computing system to determine the appropriate number of blocks based on the minimum job size and the number of processing blocks in the processing system;
in which the number of blocks in the plurality of blocks is equal to said suitable number of blocks,
in which the number of data elements in each of the blocks is approximately equal. 12. The computing system of claim 10, wherein the computer-readable instructions, when executed by one or more processing units, force the computing system:
determine whether the number of data elements in the spreadsheet exceeds the lower limit; and
use a single stream to generate a block of the final result when the number of data elements in the spreadsheet does not exceed the lower limit. 13. The computing system of claim 10,
wherein the combining streams include an incomplete internal stream when the number of blocks in the plurality of blocks is odd;
in which computer-readable instructions when executed by one or more processing units additionally force the computing system to assign one of said blocks to an incomplete internal stream; and
in which the incomplete internal stream generates a result block that contains each of the data elements in the result block generated by the child stream of the incomplete internal stream and the block assigned to the incomplete internal stream, wherein the data elements in the result block generated by the incomplete internal stream are ordered in a specified way , while the child thread is another one of the pool threads. 14. The computing system of claim 10, wherein the combining streams include a parent thread that begins to generate a result block before the child threads of this parent thread are completed by generating their result blocks, the child threads of the parent thread being other threads from the threads associations. 15. A computer-readable storage medium having computer-readable instructions stored on it, the computer-readable instructions being executed by one or more processing units in a processing system of a computing system to sort data in a spreadsheet, forcing the computing system to:
determine whether the number of rows in the pivot table exceeds the lower limit;
use a single stream to generate a block of the final result when the number of rows in the pivot table does not exceed the lower limit, and the block of the final result contains each of the rows in the pivot table, the rows are ordered in the specified way in the block of the final result;
Perform the following when the number of rows in the pivot table exceeds the lower limit:
determine the appropriate number of blocks based on the number of rows in the pivot table and the number of processing blocks in the processing system, divide the rows in the pivot table into many blocks, while the number of blocks in the said many blocks is equal to this suitable number of blocks, and the number of rows in each block is approximately equally; Use multiple block sort threads to sort the blocks so that the rows in the blocks are ordered in the specified way.
generate a stream tree, wherein the stream tree contains a plurality of join threads;
Assign two of the blocks to each sheet stream in the stream tree and wake up each join stream in the set of join threads,
in this case, each leaf stream in the stream tree generates a result block that contains each of the rows in blocks assigned to the leaf stream, and the rows in the result block generated by the leaf stream are ordered in a specified way, while each complete internal stream in the stream tree generates a block the result, which contains each of the rows in the result blocks generated by the child threads of the full internal thread, the rows in the result block generated by the full internal thread, are ordered way;
wherein the end result block is the result block generated by the root thread in the thread tree, wherein the root thread is a thread that does not have parent threads in the thread tree; and
display a sorted version of the spreadsheet, and the data elements in the sorted version of the spreadsheet are ordered in accordance with the order of the data elements in the end result block.

Images