WO2017131795A1 - Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps - Google Patents

Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps Download PDF

Info

Publication number
WO2017131795A1
WO2017131795A1 PCT/US2016/015864 US2016015864W WO2017131795A1 WO 2017131795 A1 WO2017131795 A1 WO 2017131795A1 US 2016015864 W US2016015864 W US 2016015864W WO 2017131795 A1 WO2017131795 A1 WO 2017131795A1
Authority
WO
WIPO (PCT)
Prior art keywords
time
distinct
array
representation
data
Prior art date
Application number
PCT/US2016/015864
Other languages
English (en)
Inventor
Igor Nor
Sagi Schein
Omer Barkol
Original Assignee
Hewlett Packard Enterprise Development Company Lp
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by Hewlett Packard Enterprise Development Company Lp filed Critical Hewlett Packard Enterprise Development Company Lp
Priority to PCT/US2016/015864 priority Critical patent/WO2017131795A1/fr
Publication of WO2017131795A1 publication Critical patent/WO2017131795A1/fr

Links

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2458—Special types of queries, e.g. statistical queries, fuzzy queries or distributed queries
    • G06F16/2474—Sequence data queries, e.g. querying versioned data

Definitions

  • Figure 1 is a flow diagram showing a method for obtaining and processing time-varying data according to an example
  • Figure 2A-2C are schematic illustrations showing an adjacency list representation of a time-varying graph according to an example
  • Figure 3 is a schematic illustration of a distributed system for graph analytics according to an example
  • Figure 4 is a schematic illustration showing a temporal adjacency array, a distinct chain array and an additional distinct chain array used to store part of a time-varying graph according to an example
  • Figure 5 is a schematic illustration showing an adjacency list representation of a time varying graph, stored on a non-transitory computer readable medium according to an example.
  • a user may add or remove other users.
  • connectivity between a mobile device and a base station may vary over time.
  • repositories of electronic documents such as the HyperText Markup Language (HTML) documents forming the World Wide Web, change over time as new documents get added and old documents are removed or modified. It is frequently desirable to quickly and efficiently store and/or retrieve such data.
  • HTML HyperText Markup Language
  • time-varying data which may be received as streaming data (i.e. a "data stream").
  • the data may be indicative of connections at given times between entities in a network such as a computer network or a telecommunications system.
  • the data may be indicative of e-commerce transactions wherein connections between users represent transactions between those users.
  • this time-varying or "dynamic" data is represented as a graph in a graph data structure. This then allows the data to be analyzed using graph processing techniques.
  • changes may be stored in a log file. This would enable rapid storage of data.
  • a new graph data structure would need to be constructed and processed with each data retrieval operation.
  • time-based queries may take a considerable amount of time to perform and/or fail to complete for large datasets and constrained resources.
  • Certain examples described herein allow for useful processing of time- varying data.
  • Certain examples obtain time-varying data, said data indicating at least one relationship between two defined entities that occurs at a given time. This may, for example, represent a network connection or transaction between two computing devices, or a recorded grouping or coupling between user accounts.
  • the time- varying data is then processed to configure and store an adjacency list representation of a time-varying graph based on the time-varying data. Vertices in the adjacency list representation correspond to defined entities in the time-varying data and each vertex has a corresponding neighbor list.
  • the processing comprises storing, in association with the adjacency list representation, at least one timestamp indicating a respective time of the at least one relationship.
  • a neighbor pointer is also stored, indicating elements associated with the defined entities in the at least one relationship in respective neighbor lists. For each entry in the neighbor list, a distinct chain representation is stored, each distinct chain representation indicating distinct elements of the corresponding neighbor list that are ordered based on a relationship time from the time-varying data.
  • Storing time-varying data as described in examples herein takes less time and uses fewer resources than storing, for each change (such as a new connection), a complete representation of the data at a given time. However, it also allows for fast and efficient loading of the data, for example to return a representation of the data at a request point or interval in time, as compared to a log-based approach.
  • the time-varying data is stored in non-volatile memory which provides a persistent data structure providing access much faster than a hard disk device.
  • the time-varying data for a vertex comprises three arrays.
  • a temporal adjacency array has a plurality of temporal adjacency array cells, with each temporal adjacency array cell storing data associated with a neighboring vertex, i.e. a vertex with which an edge exists, together with temporal data associated with the timing of the connection.
  • a distinct chain array has a plurality of distinct chain array cells with each distinct chain array cell indicating up to a fixed number of distinct neighbor vertices with which a connection has existed, such that the distinct chain array has a plurality of fixed-size cells.
  • An additional distinct chain array is also provided storing additional distinct neighbor vertices should the number of distinct neighbor vertices exceed the number which can be stored within the fixed sized of a distinct chain array cell.
  • the additional distinct chain array has a plurality of variable-size cells.
  • a time interval is obtained associated with a temporal portion of a time- varying graph, e.g. the graph as described above.
  • the adjacency list representation of the time-varying graph may then be loaded. This may comprise searching vertices of the adjacency list representation to locate a vertex with an associated relationship time within the requested time interval. For the located vertex, a last element is then determined within the neighbor list for the located vertex that has an associated relationship time within the time interval. This may represent the first or last connection of the vertex in question within the time interval.
  • Elements in the adjacency list representation may then be retrieved, starting from the determined last element.
  • this retrieving comprises traversing, based on at the neighbor pointers, elements within the neighbor lists that have an associated relationship time within the time interval and that form part of one of the distinct chain representations.
  • the searching of vertices and determining a last element within the neighbor list for the located vertex may comprise a binary search, and the retrieving of elements may comprise a breadth-first search. In this manner, a representation of the graph data corresponding to the time interval may be retrieved faster and more efficiently than in a system in which the stored data comprises merely a log of each change.
  • Figure 1 illustrates a flowchart showing an example of a method 100 for processing time-varying data according to an example. Although execution of the method 1 00 is described below with reference to a distributed processing system, the method 100 may be implemented by a single processor. The method 100 may be implemented in the form of executable instructions stored on a machine-readable storage medium, and/or in the form of electronic circuitry.
  • the time-varying data indicates at least one relationship between two defined entities that occurs at a given time.
  • Time-varying data may relate to an event stream, e.g. a series of events wherein each event involves two or more defined entities and occurs at a defined time.
  • the defined entities may be computers in a network, and the at least one relationship may indicate a connection between these computers, e.g. as extracted by a packet sniffing tool.
  • the defined entities may comprise elements of a telecommunications network, such as mobile devices and base stations or core network elements, with the at least one relationship similarly representing a connection between these elements.
  • the defined entities may represent users in a computing application, e.g.
  • the relationship in this case may comprise adding a particular second user to a user list of a first user.
  • the relationship may comprise a hyperlink and the entities may comprise HTML documents on the World Wide Web. It will be clear to one skilled in the art that the presently described method is applicable to other forms of data indicating relationships between defined entities.
  • the time-varying data is processed to configure and store an adjacency list representation of a time-varying graph, based on the time-varying data.
  • Vertices in the adjacency list representation correspond to defined entities in the time varying data and each vertex has a corresponding neighbor list.
  • the neighbor list indicates vertices with which connections exist to the vertex in question.
  • the adjacency list representation may comprise a plurality of array data structures. For example, a first array data structure may store a list of vertices and each entry in the list of vertices may have a corresponding linked array data structure implementing a neighbor list. These array structures may be dynamic, e.g. the number of elements in the neighbor list may change in size over time.
  • the processing at block 120 includes a number of sub- blocks.
  • At sub-block 130 at least one timestamp indicating a respective time of the at least one relationship is stored.
  • the timestamp may indicate a time of connection between two computers in a network.
  • the processing comprises storing a neighbor pointer indicating elements associated with the defined entities in the at least one relationship in respective neighbor lists. For example, a connection may exist between vertices A and B. B would then be in the neighbor list of A, and A would be in the neighbor list of B. In such a situation, a neighbor pointer associated with the representation of A in the neighbor list of B would point to the representation of B in the neighbor list of A.
  • the neighbor pointer may comprise a tuple data structure that stores the indices of A and B in their respective neighbor lists, in certain cases together with a timestamp indicating the time of connection. In one case, the timestamp is stored in association with the neighbor pointer.
  • a distinct chain representation is stored for each neighbor list.
  • the distinct chain representation indicates distinct elements of a corresponding neighbor list. As such, if a given element is repeated in a neighbor list, the distinct chain representation would indicate one instance of that element.
  • a first part of the distinct chain representation is stored in a first cell which forms part of a distinct chain array having a plurality of fixed-size cells, and a second part of the distinct chain representation is stored in a second cell which forms part of an additional distinct chain array having a plurality of variable-size cells.
  • FIGs 2A-2C are schematic illustrations that show an adjacency list representation of a time-varying graph according to an example.
  • an array or vertex list 200 which may be a dynamic array, is stored in which elements 210-1 ... 21 0-n represent vertices of the time-varying graph Vi ... Vn, including vertices Vi (210-i) and Vj (210-j).
  • each vertex a corresponding array is stored representing a corresponding neighbor list (220-1 ... 220-n).
  • These neighbor lists 220 may also comprise dynamic arrays.
  • Each neighbor list 220 comprises a list of vertex identifiers, each identifier indicating a connection between the identified vertex in the neighbor list and the corresponding vertex in the vertex list 200.
  • Figure 2A shows that a connection exists in the time-varying graph between vertex Vi and vertex Vj.
  • the neighbor list 220-i of vertex Vi includes an element 230-j corresponding to vertex Vj
  • the neighbor list 220-j of vertex Vj will include an element 230-i corresponding to vertex Vi.
  • the elements of the neighbor lists 220-1 ... 220-n may be stored in an order indicating the order in which the connections occurred.
  • elements to the right-hand side of the Figure may represent newer connections, wherein a far right element represents the most recent connection or graph edge.
  • Figure 2A also indicates schematically a neighbor pointer 240 that is stored.
  • the neighbor pointer 240 indicates a connection between the element 230-j corresponding to vertex Vj in the neighbor list 220-i of vertex Vi, and the element 230-i corresponding to vertex Vi in the neighbor list 220-j of vertex Vj.
  • the neighbor pointer 240 may comprise references to memory locations storing identifiers for vertices Vi and Vj. Given a known element in one of the neighbor lists 220-i and 220- j, the neighbor point 240 enables the corresponding element in the other neighbor list to be located.
  • a retrieval operation begins by searching vertices of the vertex list 200 to locate any vertex with an associated relationship time within the time interval. This may for example be a binary search.
  • a second search which may also be a binary search, is then performed within the neighbor list 220 of the located vertex, to find a vertex with an associated relationship time within the time interval. This may for example correspond to the first or last relationship in the neighbor list within the time interval.
  • Elements of the adjacency list representation may then be retrieved by starting at the determined element and traversing, based on the neighbor pointers, elements within neighbor lists that have an associated relationship time within the time interval. This may for example be a breadth-first search.
  • FIG. 2B shows a representation of a neighbor list 220-B for a given vertex in Figure 2A.
  • the neighbor list 220-B comprises elements corresponding to connections from the given vertex to other vertices in the graph data structure, the other vertices being represented by the characters a, b, c, d, e (e.g. said characters comprise identifiers for the vertices).
  • Multiple connections occur between the given vertex and some of the other vertices, and as such the neighbor list 220-B may comprise multiple elements corresponding to a single other vertex. For example, the repeated inclusion of the identifier for vertex a, may represent multiple connections over time between the given vertex and vertex a.
  • a distinct chain representation is used to determine all vertices that have connections that occur within that time interval. In this case, it is deemed sufficient to know that at least one connection occurred between two vertices in a requested time interval, without returning further information regarding the nature of any connections within the time interval. By returning information regarding entities active within a time period, but reducing the amount of information regarding specific connections within that time period, graph retrieval operations may be increased in speed.
  • a distinct chain representation 250 is stored for each neighbor list.
  • the distinct chain representation indicates distinct elements of its corresponding neighbor list. That is to say, it skips repeated instances of the elements corresponding to connections with the same vertex.
  • the distinct chain representation indicates the first occurrence of a connection to a particular other vertex. In other embodiments, it may for example indicate the last occurrence of a connection to a particular other vertex.
  • the distinct chain representation may comprise at least one pointer, each said pointer being associated with a distinct element of the corresponding neighbor list and referencing a further distinct element of the corresponding neighbor list.
  • a set of pointers may link the distinct elements of the neighbor list.
  • the distinct chain representation may comprise at least one timestamp associated with an element of the distinct chain representation. For example, where the distinct chain representation comprises at least one pointer associated with a distinct element of the corresponding neighbor list, a timestamp may be associated with each of these pointers indicating the time at which that pointer was created.
  • Figure 2C shows the array structure of Figure 2A, wherein a distinct chain representation 250-1 ... 250-n is stored for each neighbor list 220-I ... 220-j.
  • the use of a distinct chain representation may be extended to include additional information regarding connections within a requested time or time period.
  • at least one count indicating a number of relationships between at least two defined entities occurring in a given time interval may be stored in association with the adjacency list representation.
  • the distinct chain representation may comprise a hash table indicating distinct elements of the corresponding neighbor list.
  • an element corresponding to Vi is stored at one end of the neighbor list 220-j corresponding to Vj, and an element corresponding to Vj is stored at one end of the neighbor list 220- i corresponding to Vi.
  • a neighbor pointer is then stored indicating the connection between these elements.
  • the distinct chain representation is also updated. For example, as described above, the distinct chain representation may identify the most recent connection between a vertex and each relevant other vertex. On obtaining a new connection between vertices Vi and Vj, The distinct chain representation is updated to identify that connection instead of any previous connection between vertices Vi and Vj.
  • a timestamp may also be stored, indicative of the time of updating the distinct chain representation.
  • storing a distinct chain representation for said neighbor list comprises adding the new element to an end of the distinct chain representation and removing any element having a same value as the new element from the distinct chain representation.
  • a new connection to element c would result in the links from b to c and c to d being removed and replaced with a new link from b to d (in addition to a new link from c to a).
  • This process takes a constant period of time (O(1 )) for each new connection and so is independent of the size of the dataset. It is thus straightforward to assign computing resources for the storage of new connections.
  • representations of relationships may be removed from the adjacency list representation. For example, relationships may be removed after a given amount of time has elapsed. Removing a relationship between vertices Vi and Vj comprises removing elements corresponding to the relationship from the neighbor list 220-i of vertex Vi and from the neighbor list 220-j of vertex Vj. A timestamp may be stored indicating the time at which the removal occurred. As the elements of each neighbor list are time-ordered, removal of the earliest stored relationship comprises removing the first element of the corresponding neighbor lists.
  • Certain examples described above enable events from a data stream, (time-varying data) to be efficiently stored.
  • examples of a corresponding loading or data retrieval operation are described. These examples enable portions of a time-varying graph data structure to be retrieved in response to a query having a particular time or time period.
  • a time interval associated with a temporal portion of a time-varying graph is first obtained.
  • a representation of the time-varying graph data may then be loaded that corresponds to that time interval.
  • vertices of the above-described adjacency list representation are searched to locate a vertex with an associated relationship time within the time interval. This may be, for example, a binary search.
  • a search which again may be a binary search, is performed within its neighbor list to determine an element that has an associated relationship time within the time interval. This may correspond to the first relationship in the neighbor list within the time interval, in examples in which the distinct chain representation indicates the first occurrence of each vertex, such that the element is represented in the distinct chain representation.
  • the distinct chain representation indicates the last occurrence of each vertex
  • this may advantageously correspond to the last relationship in the neighbor list within the time interval.
  • Elements in the adjacency list representation may then be retrieved by starting at the determined element and traversing, based on the neighbor pointers, elements within neighbor lists that have an associated relationship time within the time interval and that form part of one of the distinct chain representations. This may for example be a breadth-first search. Upon following a neighbor pointer, this may comprise advancing through the distinct chain until the last element of the time interval, then travelling backward until reaching the end of the time interval. In this manner, a representation of the relationships associated with the time period may be efficiently loaded.
  • a binary searches may take 0(log(E)) time to perform, where E is the number of edges or connections present in the graph data structure.
  • a breadth first search may take 0(Vi + Ei) time to perform, where Vi represents the number of vertices or entities within the requested time interval and Ei represents the number of edges or connections within the requested time interval.
  • a complexity of the loading operation is 0(log(E)+ Vi + Ei).
  • a breadth first search may take 0(Vi* + Ei*) time to perform, where Vi* represents the number of unique or distinct vertices or entities within the requested time interval and Ei* represents the number of unique or distinct edges or connections within the requested time interval.
  • Vi* represents the number of unique or distinct vertices or entities within the requested time interval
  • Ei* represents the number of unique or distinct edges or connections within the requested time interval.
  • a complexity of the loading operation is 0(log(E)+ Vi* + Ei*).
  • the time required may be modelled and appropriate computing resources may be assigned to perform the operation.
  • FIG. 3 schematically shows a distributed system for graph analytics according to an example.
  • the distributed system includes a master node 305 and a plurality of worker nodes 31 0a to 31 On, hereafter referred to as worker nodes 31 0, interconnected by a message passing system 31 5.
  • each of the master node 305 and the worker nodes 31 0 is formed by a system on a chip.
  • the plurality of worker nodes 31 0 have respective core processors 320a to 320n, hereafter referred to as core processors 320.
  • the message passing system 31 5 allows for communication of messages between the master node 305 and the worker nodes 31 0, and also allows for communication of messages directly between the worker nodes 310. Although schematically shown in Figure 3 as being outside of the master node 305 and the worker nodes 31 0 for ease of illustration, it will be appreciated that parts of the message passing interface 31 5 may be provided in the systems on a chip for the master node 305 and the worker nodes 310.
  • the message passing system 315 comprises the Message Passing Interface.
  • the worker nodes 310 can access time-varying graph data stored by a shared memory 325 via a memory management module 430.
  • the shared memory 325 distributes the graph data between a plurality of non-volatile memories 335a to 335m, hereafter collectively referred to as NVMs 335.
  • the memory management module 330 provides the worker nodes 310 with shared access to the shared memory 325.
  • the memory management module 330 is schematically shown as being outside the worker nodes 310 and the distributed memory 325 for ease of illustration, it will be appreciated that at least part of the memory management module 330 may be located in the same hardware devices as the worker nodes 310 and the NVMs 335.
  • the memory management module may be implemented in software, hardware or a combination of software and hardware.
  • the NVMs 335 may be any form of non-volatile memory.
  • the NVMs may be formed using memristor technology.
  • the master node 305 has program code for a graph data insertion interface 340, a graph query interface 345, a task dispatcher 350, a graph composer 355 and a task monitor 360.
  • the graph data insertion interface 340 receives data from a data source 365, for example a telecommunications network or a social network, and inserts the data as new vertices or edges in the time-varying graph stored by the distributed memory 325. In an example, this is achieved by the graph data insertion interface 340 allocating tasks for achieving the data insertion to the plurality of worker nodes 310. This allocation may be made on the basis that each worker node 31 0 is responsible for a respective portion of the time-varying graph, for example the portion of the time varying graph stored on one of the NVMs 335. The tasks are then sent by the task dispatcher 350, via the message passing system 315, to their respective worker nodes 310.
  • a data source 365 for example a telecommunications network or a social network
  • the graph query interface 345 receives and processes a query from a query application 370, which may be for example a web application.
  • a query application 370 which may be for example a web application.
  • An example of a query that may be received is a "k-hop" query for a prescribed time interval, which requests details of all paths from a query vertex of the time-varying graph having a depth of up to k edges over the prescribed time interval.
  • the graph query interface 345 allocates tasks for implementing the query to the plurality of worker nodes 310, and then the allocated tasks are sent by the task dispatcher 350 to their respective worker nodes 310 via the message passing system 315.
  • Reply data for the query is then received from the worker nodes 31 0 via the message passing interface 315, and collated in the graph composer 355.
  • the collated data is then processed by the graph query interface 345 to generate further tasks or answer data for sending to the query application 370.
  • FIG. 4 shows in more detail the array structure used to store the neighbor cell list and distinct chain representation for certain examples.
  • the neighbor list is stored in a temporal adjacency array having a plurality of temporal adjacency array cells.
  • Each temporal adjacency array cell corresponds to an element in the neighbor list, i.e. a connection to a neighbor vertex, and accordingly the number of temporal adjacency array cells matches the number of connections.
  • Each temporal adjacency array cell has the same size, and stored data such as a pointer to the neighbor vertex and a timestamp. Once a temporal adjacency array cell has been filled then the filled temporal adjacency array cell can be transferred to non-volatile memory for storage.
  • the distinct chain array has a plurality of distinct chain array cells, with each distinct chain array cell corresponding to a respective temporal adjacency array cell such that the number of distinct chain array cells matches the number of connections.
  • the size of each distinct cell array cell is fixed. However, the number of distinct connections to a vertex will vary over time and from vertex to vertex. Accordingly, a distinct chain array cell is not necessarily filled, with the number of incomplete cells being at most the number of different neighbors for a vertex. Further, the size of a distinct chain array cell may not be large enough to store data indicative of all distinct connections to the vertex.
  • the additional distinct chain array has a plurality of additional distinct chain array cells which will necessarily match the number of temporal adjacency array cells, given that for some temporal adjacency array cells the number of distinct connections may be equal to or less than the number that can be indicated in a distinct chain array cell.
  • the size of each additional distinct chain array cell is not necessarily the same. In other words, the additional distinct chain array cell are non-uniform in size. Each additional distinct chain array cell will be completed synchronously with the corresponding distinct chain array cell.
  • Figure 5 depicts a non-transitory computer-readable medium 510 storing data 520 representative of a dynamic graph.
  • the computer-readable medium 51 0 may be connected to a processor 530.
  • the computer-readable medium 510 may comprise any machine-readable storage media, e.g. such as a memory and/or a storage device.
  • the computer-readable medium comprises nonvolatile memory.
  • the processor 530 may be arranged to store data 520 in memory such as RAM during active storing and/or loading of graph data.
  • processor 530 may be arranged to store data 520 in a persistent storage device such as a hard disk or solid state device as part of a storing and/or loading operation.
  • the data 520 comprises an adjacency data structure 540, the adjacency data structure 540 comprising an array of vertices 545 and a set of temporal adjacency arrays 548 corresponding to said vertices, for example as described above.
  • the data 520 further comprises a set of distinct chain arrays 550 and a set of additional distinct chain arrays 560, for example as described above.
  • the data 520 may comprise the data that is generated as part of the store operation described above. It may also comprise data that is interrogated to load a portion of a time-varying graph as described above.
  • the non-transitory computer-readable medium 510 also stores graph data insertion instructions executable by the processor 530 to insert new data into the adjacency data structure 540 and modify the set of distinct chain arrays 550 and the set of additional distinct chain arrays 560 accordingly as set out above. Further, the non-transitory computer-readable medium 51 0 also stores graph data query instructions 580 executable by the processor 530 to perform query operations on the time-varying graph data.
  • Certain examples described above allow for efficient storing and subsequent loading of time-varying graph data, for example received as streaming data.
  • storing a log file of received events allows for rapid storage and requires relatively low disk space.
  • retrieving data involves constructing a new graph data structure for each retrieval operation, which may take a considerable amount of time to perform and/or fail to complete for large datasets and constrained resources.
  • storing a complete copy of a graph data structure for each received event allows for efficient retrieval but requires significant time and resources at the time of storage.
  • Certain examples described herein allow for such data to be efficiently received, stored, and subsequently loaded. This allows for such processing and storage to be implemented with a reduced time and computing resource burdens.

Abstract

Des exemples de l'invention concernent un traitement de données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps Dans ce cas, les sommets dans la représentation par liste d'adjacence correspondent à des entités définies dans les données variant dans le temps et chaque sommet possède une liste de voisins correspondante. Des pointeurs de voisins sont fournis, indiquant une relation entre des éléments de l'ensemble de tableaux de voisins. Une représentation en chaîne distincte est également utilisée pour chaque liste de voisins, chaque représentation en chaîne distincte indiquant les éléments distincts d'une liste de voisins correspondante qui sont ordonnés d'après une date de relation issue des données variant dans le temps. Une première partie de la représentation en chaîne distincte est stockée dans une première cellule ayant une taille fixe et une seconde partie de la représentation en chaîne distincte est stockée dans une seconde cellule de taille variable.
PCT/US2016/015864 2016-01-31 2016-01-31 Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps WO2017131795A1 (fr)

Priority Applications (1)

Application Number Priority Date Filing Date Title
PCT/US2016/015864 WO2017131795A1 (fr) 2016-01-31 2016-01-31 Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
PCT/US2016/015864 WO2017131795A1 (fr) 2016-01-31 2016-01-31 Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps

Publications (1)

Publication Number Publication Date
WO2017131795A1 true WO2017131795A1 (fr) 2017-08-03

Family

ID=59398881

Family Applications (1)

Application Number Title Priority Date Filing Date
PCT/US2016/015864 WO2017131795A1 (fr) 2016-01-31 2016-01-31 Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps

Country Status (1)

Country Link
WO (1) WO2017131795A1 (fr)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115774800A (zh) * 2023-02-10 2023-03-10 之江实验室 基于numa架构的时变图处理方法、电子设备、介质

Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20070239677A1 (en) * 2006-03-28 2007-10-11 Microsoft Corporation Predicting community members based on evolution of heterogeneous networks
US20080162552A1 (en) * 2006-12-29 2008-07-03 Sap Ag System and method for processing graph objects
US20090303239A1 (en) * 2008-06-04 2009-12-10 Darwin Ang Methods and systems for creating and editing a graph data structure
US20130013534A1 (en) * 2011-07-07 2013-01-10 International Business Machines Corporation Hardware-assisted approach for local triangle counting in graphs
WO2013149381A1 (fr) * 2012-04-05 2013-10-10 Microsoft Corporation Plate-forme de calcul et de mise à jour de graphes en continu

Patent Citations (5)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
US20070239677A1 (en) * 2006-03-28 2007-10-11 Microsoft Corporation Predicting community members based on evolution of heterogeneous networks
US20080162552A1 (en) * 2006-12-29 2008-07-03 Sap Ag System and method for processing graph objects
US20090303239A1 (en) * 2008-06-04 2009-12-10 Darwin Ang Methods and systems for creating and editing a graph data structure
US20130013534A1 (en) * 2011-07-07 2013-01-10 International Business Machines Corporation Hardware-assisted approach for local triangle counting in graphs
WO2013149381A1 (fr) * 2012-04-05 2013-10-10 Microsoft Corporation Plate-forme de calcul et de mise à jour de graphes en continu

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CN115774800A (zh) * 2023-02-10 2023-03-10 之江实验室 基于numa架构的时变图处理方法、电子设备、介质

Similar Documents

Publication Publication Date Title
US10467245B2 (en) System and methods for mapping and searching objects in multidimensional space
US11386091B2 (en) Joining large database tables
CN111460023B (zh) 基于Elasticsearch的业务数据处理方法、装置、设备及存储介质
CN112287182B (zh) 图数据存储、处理方法、装置及计算机存储介质
WO2017131791A1 (fr) Gestion analytique de grappe d'évènements de journal
CN104679778A (zh) 一种搜索结果的生成方法及装置
WO2018036549A1 (fr) Procédé et dispositif d'interrogation de base de données distribuée, et système de gestion
CN110928851B (zh) 处理日志信息的方法、装置、设备及存储介质
US11250166B2 (en) Fingerprint-based configuration typing and classification
CN112015820A (zh) 分布式图数据库实现的方法、系统、电子装置和存储介质
CN111061758B (zh) 数据存储方法、装置及存储介质
CN111753016A (zh) 数据处理方法、装置、系统及计算机可读存储介质
CN110245134B (zh) 一种应用于搜索服务的增量同步方法
CN110955704A (zh) 一种数据管理方法、装置、设备及存储介质
AU2014253497B2 (en) Entity resolution from documents
US20140279883A1 (en) Method and a system for distributed processing of a dataset
CN111625617A (zh) 一种数据索引方法、装置及计算机可读存储介质
WO2017131795A1 (fr) Traitement des données variant dans le temps au moyen d'une représentation par liste d'adjacence d'un graphe variant dans le temps
Marinov A bloom filter application for processing big datasets through mapreduce framework
CN110990394B (zh) 分布式面向列数据库表的行数统计方法、装置和存储介质
US10019472B2 (en) System and method for querying a distributed dwarf cube
CN113032368A (zh) 一种数据迁移方法、装置、存储介质及平台
CN112527776A (zh) 数据稽核方法、装置及存储介质
WO2017014744A1 (fr) Traitement de données variant dans le temps à l'aide d'une structure de données en graphe
CN117009439B (zh) 数据处理方法、装置、电子设备及存储介质

Legal Events

Date Code Title Description
121 Ep: the epo has been informed by wipo that ep was designated in this application

Ref document number: 16888523

Country of ref document: EP

Kind code of ref document: A1

NENP Non-entry into the national phase

Ref country code: DE

122 Ep: pct application non-entry in european phase

Ref document number: 16888523

Country of ref document: EP

Kind code of ref document: A1