DE102017109383A1 - Method for data communication using random network addresses and corresponding device - Google Patents

Abstract

A method of data communication and computation over a network, wherein nodes of the network are capable of evaluating functions in the node's local environment, and where the addresses of newly formed or newly connected network nodes are randomly assigned, with an almost uniqueness of nodes Addressing is achieved by using a random or pseudo-random method of selecting an address from a sufficiently large pool of network addresses.

Description

In a first aspect, the present invention is a method of forming computer machinery from a plurality of separate networked components, wherein the method of assigning addresses to individual network nodes is configured to address the possibility of a node in the network or subnet having the same address as another node in the network or subnet has to render unlikely to any required degree of security, and to communicate messages to and from such nodes with assigned addresses to other and possibly different nodes with possibly different addresses in the computer -Network. The plurality of separate network nodes are capable of computing functions on the data sent to them, of responding to the data resulting from the calculations, or of transmitting such results to other nodes in the network.

The prior art for the present invention involves the use of Universally Unique Identifiers (UUID), which is a numeric value, typically 128 bits, with the meaning of each bit being defined by any of several variants. In canonical form, such as the one used by the IPv6 network protocol, a 128-bit UUID is represented by 32 lower-case hexadecimal digits, displayed in five groups separated by hyphens. An example of such a UUID is fd30: 0000: 0000: 0001: ff4e: 003e: 0009: 000e.

The prior art includes the use of a UUID with an MD5 hash value derived from a URL, or a domain name, or an object identifier or a Distinguished Name (DN) as used in the Lightweight Directory Access Protocol ), such as set in Version 4 of RFC 4122 of the Network Working Group, July 2005 ,

The prior art involves the use of a UUID that depends primarily on random numbers, for example, those that are in Version 4 of RFC 4122 ("Leach Salt") and Version 5 of RFC 4122 (SHA-1 hash over a namespace) are set ,

The prior art contains the technology which 2008 by the pseudonyms Satoshi Nakamoto in the paper titled "Bitcoin: A Peer-to-Peer Electronic Cash System" also disclosing prior art computer techniques such as hashing, time stamping, and solving problems with design evidence.

The prior art includes WIPO 1020140106871, convergence communications using a virtual private network and related apparatus which teaches that randomly assigned IP addresses can be used in a device, wherein the random addresses are collected and bound to user terminals then the bindings are transferred to a binding server where they are stored for retrieval by call sessions.

The prior art includes WIPO 201410100927.2, which teaches a method and apparatus for data transmission over a backbone computer network consisting of a routing node and at least two data servers, the first server transmitting a message conveying communication information to the routing node the backbone network is transmitting. Then, the routing node determines the address of the destination server according to the first message, and transmits the communication information to the destination server.

The prior art also includes WIPO 1020120090701, a user authentication system and method in a mobile device that teaches the use of random numbers to authenticate users having mobile devices, broadcasting the random numbers to the device, and requesting the user to authenticate by entering the number, wherein such an authentication check with a stored database of these random numbers is performed, which correspond to the user and the device authentication.

The present invention is a method of communicating between nodes in a network by assigning network nodes to randomly selected network addresses. In a preferred implementation of the method, there is no central storage system or repository of available network addresses. Thus, collisions may occur where two or more network nodes have the same address within the network.

The prior art has also shown some methods of assigning network identifiers, which differ from the present invention in that (1) it is not random, or (2) random, but with one or more memories tuned are to ensure that two nodes are not assigned to the same network address (a collision), or that if such an assignment is made, then one or the other node is immediately assigned to a new address.

This method of using a separate memory or database of available (or equivalent, unavailable) network addresses has the advantage of ensuring that there are no collisions, or if collisions are detected, they are resolved quickly so that they do not occur again. Because network addresses are unique, messages can be easily sent from one node to another.

In order to implement the prior art methods, each account wishing to send information to a receiving node must make a request from the central storage node to determine the destination address of each data packet to send from the sending node to the receiving node is. This process of requesting for the node addresses takes a significant amount of time, which increases at least linearly with the number of nodes in the network. This prevents networks from having more than a billion or so at network nodes capable of intercommunication.

The state of the art includes WO / 2015/066527 A method and apparatus for determining the use of an X2 gateway for an x2 interface, wherein a receiver in a wireless communication system receives messages in response to detecting a neighbor node to determine the method of communication, which direct communication or indirect communication over the Gateway, which is selected in the indirect method based on the address indication.

The prior art teaches that newly formed network nodes must broadcast or otherwise transmit their identification to existing network nodes, including their network address or a unique hardware identifier. One or more of the receiving nodes then store / store the assigned network address in the memory, being available to other nodes through a communication path of arbitrary length. This method has the disadvantage that the amount of memory required to store these network addresses grows at least linearly with the number of nodes in the network. This method further has the advantage that the time delay required for a node to discover the network address from another node increases at least linearly as the number of nodes increases.

The present invention generally replaces a central address memory which detects network address collisions with a network address space which is sufficiently large that the probability of collisions of randomly assigned network addresses can be made as small as desired.

An advantage of the present invention is that no storage space is required in the sending or receiving nodes for the purpose of storing the addresses of the other nodes.

Another advantage of the present invention is that the central memory of the network addresses is eliminated and no request of the central memory needs to be made.

was für kleine Exponenten

ist, was grob

ist, wobei n die Anzahl von UUIDs ist, welche erzeugt wurden, und x die Anzahl von Bits ist. Dies bedeutet zum Beispiel, dass bei der Verwendung von = 128 Bitnummern für UUIDs, und einem Erzeugen von einer Million UUIDs pro Sekunde für die nächsten 100 Jahre (100 Jahre sind ungefähr 3,153,600,000 oder 3·10¹⁰ Sekunden), die Anzahl von UUIDs, welche erzeugt wurden, ungefähr n ≈ 3·10¹⁶ sein würde. Wird in die obige Formel n² ≈ 10³³ eingefügt, so dass die Wahrscheinlichkeit des zweimaligen Zuweisens der gleichen UUID bei einer Million von Trillionen von UUIDs, welche erzeugt wurden, ungefähr

sein würde, was

ist oder eine Wahrscheinlichkeit von Zehnmillionen, dass eine einzige Kollision auftritt. Zum Vergleich beträgt die durchschnittliche Ausfallrate von nicht korrigierbaren Speicherfehlern pro Jahr ungefähr 1,3 %, so dass die Wahrscheinlichkeit einer Adress-Kollision mit 128 Bit Adressen ungefähr ein Milliardstel der Wahrscheinlichkeit der heutigen CPU Ausfallrate ist. The probability of a collision (non-unique address assigned to different network nodes) can be easily calculated by using Probability Theory, but is approximate

what little exponents

is what rough

where n is the number of UUIDs that were generated and x is the number of bits. This means, for example, that when using = 128 bit numbers for UUIDs, and generating one million UUIDs per second for the next 100 years (100 years is approximately 3,153,600,000 or 3 × 10 ¹⁰ seconds), the number of UUIDs is would be about n ≈ 3 · 10 ¹⁶ . Is inserted in the above formula n ² ≈ 10 ³³ , so that the probability of assigning the same UUID twice to a million of trillions of UUIDs generated approximately

what would be

or a ten million chance that a single collision will occur. By comparison, the average failure rate of uncorrectable memory errors per year is about 1.3%, so the probability of an address collision with 128-bit addresses is about one-billionth of the probability of today's CPU failure rate.

An implementation of the present method of claim 1 uses 128-bit addresses. The advantage of using 128-bit addresses is that many address routing problems as well as other definition problems have been extensively studied or solved, in principle, because IPv6 networks use 128 bits.

In one implementation of a system such as that described in claim 1, nodes must store the current address of other nodes with which they are communicating. This allows the implementation of massively parallel data processing systems, where a node is constructed to compute a particular function, then that node is instantiated and replicated multiple times, each instance having a different but identifiable network address. These multiple nodes are configured to receive broadcast messages and to compute user-defined functions on data contained within the system, thereby achieving massively parallel communication.

The system described by claim 1 is based on random or pseudorandom algorithms. The prior art includes methods of generating both true random and pseudo-random numbers of any desired size. Real random numbers can be generated by any number of physical processes, such as radioactive noise or photon generators. Pseudo-random numbers can be generated by any of a variety of well-known methods, such as a linear congruence generator. Since physical phenomena generally have asymmetries and systematic tendencies that do not make their results uniformly random, a preferred method that has been demonstrated in the prior art to use a cryptographic hash function to avoid uniform distribution of bits from one -uniform random source. The particular methods of generating random numbers are not a claim of this patent.

• • Prozesse sind streng isoliert
• • Prozesse sind leicht zu bilden und zu zerstören
• • Nachrichtenaustausch ist die Art, wie die Prozesse interagieren
• • man kann Nachrichten nur zu Prozessen senden, deren Namen einem bekannt sind
• • Prozesse teilen Ressourcen nicht
• • Fehlerbehandlung ist nicht lokal

The nodes of the network are able to perform calculations. The preferred implementation is that the nodes execute statements in any language, preferably functional and in the manner of the Erlang language or the Lisp language. In the Erlang language: every statement is a process

• • Processes are strictly isolated
• • Processes are easy to form and destroy
• • Message exchange is the way the processes interact
• • You can only send messages to processes whose names are known to you
• • Processes do not share resources
• • Error handling is not local

In Lisp or other functional voice implementations of the present invention, the above requirements still have to be met.

Preferably, the nodes of the network exchange messages through an asynchronous shared-nothing messaging system, each node having a queue of messages that have been sent by other nodes and have not yet been consumed. Messages are consumed when the node calls the "receive" primitive to receive messages that correspond to desired patterns. Consuming such messages can and does involve often executing pieces of the messages as code in the computer language.

In the following example, using the Erlang notation, we form a new node and perform any function within that node: RemoteProcessId = spawn (RemoteNode, FunctionCode, [Port, MaxCon]),

It is not necessary for the invention that the computer language used is Erland, but it must be a language that implements the above-mentioned restrictions.

In a second aspect, the invention relates to a data fusion object and a networked system for the evaluation of calculable functions with means for local or parallel functional evaluation, filtered data input and output, and process dependent input and output of one or more encapsulated functional objects to other such objects, and to computer and computing devices and systems provided locally or on the Internet.

The system according to the invention comprises so-called data fusion objects (DFOs) which are capable of communicating with other DFOs through a network (N), the network N having a large number of available network addresses. A DFO is a physical (hardware-implemented) or logical (software-implemented) object that:

• (1) exists in an external environment;
• (2) has an internal environment comprising (i) as a DFO procedure and (ii) properties;
• (3) implements a term evaluator
• (4) is able to form new DFOs within the environment;
• (5) is able to destroy new DFOs within the environment; and
• (6) is able to communicate with DFOs within its internal and external environment.

Some further aspects of the invention are defined in the appended claims. These aspects as well as further aspects of the invention are given and explained in the description and the drawing.

The terminal node (highest level) of a DFO system is an external environment, that is, its own internal environment.

A DFO method is a computer process that implements a function whose input data is DFO properties, and whose evaluation modifies the internal state of the DFO and may or may not cause the formation or destruction of one or more sub-DFOs, and the data may or may not communicate over one or more networks (including networks that implement IP, such as the Internet). It will open 1 for a general overview.

DFO properties are data that can be evaluated by DFO functions.

The external environment of a DFO is itself the internal environment of any other DFO, except the highest level external environment whose external environment it is itself.

1 represents DFOs in their respective environments.

notation

In the following, examples of implementation details are presented to clarify the textual explanation. These examples are generally written in the computer language Scheme and are identified by a font such as: "This is an example of an implementation detail." There is no requirement that such a system be written in a schema or in any other functional language, provided that the language used is capable of calculating finite recursive functions.

Properties and procedures

Properties can themselves be represented as data and data can be evaluated as a method. Methods are used as data when forwarded to a DFO and data are methods when they are received by a DFO and deconstructed to implement procedures. In the above, forwarding and receiving DFOs may be the same DFOs or different DFOs.

In the descriptions and examples used herein, both methods (code) and properties (data) are written as S-expressions in a Lisp-like language. This is not a necessary or essential feature: a DFO system can use any computer language capable of calculating recursive functions.

An example of a method used as data is a DFO which takes as its input a method to compute log ₁₀ (x) and returns by modifying the code by this method as a method to return log ₂ (FIG. x) to calculate. In this example, the input data itself is a method.

For a DFO, there is no fundamental distinction between procedure and properties (data), although, when talking about the DFO system, it is often useful to classify the internal arithmetic functions as procedures and expressions used as DFO inputs and outputs or as arguments Procedures used to classify properties.

DFO environments

The environment of a DFO is similar to a Closure in the Scheme programming language. One difference is that self-checking environments are available, not hidden, as they are typically in Common Lisp or Scheme. This means that environments are treated as First Class objects that are able to be sent to another DFO, in whole or in part. The receiving DFO can therefore evaluate computable functions within the environment of the transmitting DFO without the need for further communication between these two DFOs.

DFO procedure

Methods (typically implemented as functions and typically as lamda expressions) embedded in a DFO as first class objects. Since a DFO procedure is implemented as a lambda expression, it can be expressed as a list and then interpreted as a procedure again. This makes it possible to write a self-modifying code and form DFOs which modify methods which are transmitted to them.

Results of applying procedures affect the local environment and may also have side effects. One such side effect is that one method may send the result of its calculation to another DFO, implementing a callback mechanism.
(send-message: to another-DFO '(send to `[self *] some-stuff-to-evaluate))
where, as is common in Lisp or Scheme, the single quote symbol (') indicates the following expression, and the symbol inverted apostrophe (`) (that is, it evaluates to) ends the following expression.

DFO addressing and embedding

Inputs and outputs of DFOs are packets sent and received through network addresses in the form of [addr]: port. This is preferably implemented using IPv6. A DFO forwards a message to another DFO by sending a set of IP packets to a specific port and receives messages from other DFOs by receiving IPv6 packets from a specific port on the other DFO.

A DFO can be embedded in another DFO. This is implemented in IPv6 by sub-networking. Typically, the sub-networked DFO addresses are not hierarchically expressed above the embedded DFO; rather, messages to and from the sub-linked DFO are sent to the mother DFO using child DFOs as subroutines or sub-processes.

A DFO itself can be forwarded as data to another DFO, either by forwarding the IPv6 address [DFO] or by forwarding the environment (including procedures and properties) of the DFO to be forwarded. In the first case, the DFO is a co-process type. In the second case, a new copy of the DFO is formed whose address space and environment is independent of the first DFO.

An example is a DFO that takes as its input a list of numeric values, then returns a list of English words for those numbers. This DFO could be directed to another DFO, which takes English words as input and outputs corresponding French words. This can be done in two ways.

The first way is to form the English-to-French DFO with any IPv6 address [English-to-French] and, at the same hierarchical level, the DFO with the address [Numbers-to-English]. Then a DFO number-in-French is formed which receives a stream of numbers and which calls the two DFOs defined above with the addresses, issuing a stream of French words. Another way to accomplish this is to define numbers-in-French within the numbers-in-English environment, with (for example) a different and newly formed address assigned to it.

Each DFO has its own internal environment and is able to accept some set of expressions {S _j } from itself or from other DFOs and to evaluate expressions {S _i }. Each DFO is capable of expressing the calculated value R _{j, n} (f _j (S _i )) which is S _j evaluated in the vicinity of the DFO _i

and expressed (made available for access via any output port n by another set of DFOs, which are often the calling DFOs).

An implementation of the data fusion object system can be performed using IPv6. Such a system can be implemented as a set of IPv6 objects that can communicate with each other and with other devices or people. Each DFO has its own (usually unique) IPv6 address, which is used as a handle or as an identifier for the DFO. In terms of notation, the identifier [<DFO _x >]: port is the IPv6 address for DFO _x with an IPv6 port specification of the port.

Some DFO addresses [<DFO _x >] will be publicly available on the Internet. These addresses will be used for communication of the DFO system with other users or with machines located on the Internet. Others will be local.

Local DFO addresses are either specified by DFO _creator or selected by some hash algorithm. The hash algorithm could possibly be a sequential counter or could be assigned by a DFO function, or could be selected by any other method capable of generating unique DFO identifiers, including possibly a random number.

A random number can be used as a DFO address if speed of education is required. Due to the large size of the FD00 :: / 8 (local) address space (2 ^ 40 or about 10 ^ 12, which is one trillion), the probability of a DFO address collision is negligible in most viable systems, far less than the probability of one Hardware failure for most such systems.

If this address space is too small for some very large systems, then another local scheme (including FC00 :: / 7) or any other non-routed scheme could be selected. S These schemes are generally not in strict accordance with RFC 2460, Internet Protocol, Version 6 (IPv6) specification issued by the Internet Engineering Task Force (IETF) and later RFCs describing the architecture and services supported by IPv6. If the default assignments of IPv6 are overridden, the DFO system could work with this type implemented by network, potentially be of a size of 2 ^ 128, which is about 3.8 × 10E38. For such large address spaces, address collisions are negligible, even with very large systems.

Within the DFO frame, there is no distinction (besides the address generation algorithm) between local and other addresses. This allows seamless integration of DFO systems located elsewhere on the Internet and elsewhere in the physical world.

Within the DFO system, the expression (evali S) means that the term S is evaluated within the environment of a DFOj. The environment of two different DFOs can be quite different. An environment contains functional and data bindings as well as an expression evaluator. As an example, the expression (evaldfo-1 V) will evaluate TRUE if V is set to TRUE in DFO ₁ , but (evaldfo-2 V) will return to FALSE if V is set to FALSE in DFO ₂ .

Environments are not static. An evaluation of DFO functions can change the states of the variables within the environment. A DFO _set can be a variable in another DFO _get set by calling a function such as
(dfo-evaluate [DFO _get ]: 0 (setf × value))

A DFO can itself be a data object, as previously mentioned. The example given (changing the language of the words representing a list of numbers) could be pseudo-coded as follows:

In this example, [DFO _translate ] has been given as an input to the DFO, and is used as a 'sub-dfo' to perform the translation. The higher level DFO knows nothing about

1. EDUCATION OF A DFO

• a. DFOs are made by other DFOs. A DFO system begins with one or more predefined DFOs capable of forming other DFOs. DFOs have unique addresses and have a number of input / output ports at each address. The ports are used for communication between DFOs.
• b. To form a new DFO, one of the predefined DFOs, for example DFO1 with the address [DFO1], calls the function (dfo-create args), where args is any set of arguments to set initial values and function bindings.
• c. (dfo-create args) allocates some memory and processor resources and loads a copy of the DFO _default code into these resources.
• d. A DFO could override this action by specifying another source for the initial load by supplying arguments to dfo-create, such as (dfo-create: default (new-load) args).
• e. For example, a DFO can make another DFO which is a copy of itself by supplying arguments to dfo-create, such as (dfo-create: default * myself * args). In this case, where * myself * is the representation of the current state of the forming DFO, DFO _{created is} exactly the same as DFO _creating in all respects, except that any activity is interrupted by DFO _created until the arguments (dfo-create args) are evaluated.
• f. Before any other activity, including I / O activity, a new DFO will evaluate the arguments given to the (dfo-create args) function.

2. Evaluation within a DFO

• a. If a DFO forms another DFO, for example, by calling a method that we could call "(dfo-create args)".

• b. Eines der möglichen Argumente für den Aufruf, ein neues DFO zu bilden (benannt wie oben “dfo-create”), ist die Spezifikation eines Kommunikations-Ports, über welchen DFO_created erwartet, Nachrichten mit DFO_creating auszutauschen. Eine mögliche Implementierung ist (dfo-create :comport-in value1 :comport-out value2 rest-of-args) welche abgekürzt werden kann (dfo-create :comport value ...), wenn value1 gleich value2 ist. Dieser Kommunikations-Port ist typischerweise gleich Null für lokale DFOs, muss jedoch für DFOs spezifiziert werden, auf welche extern zugegriffen werden kann.
• c. Evaluierung der Argumente an (dfo-create args) bewirkt typischerweise die folgenden Schritte: i. DFO2‘s IPv6 Adresse [DFO_self] wird gesetzt, entweder durch Spezifizieren eines Adressbereichs (dfo-create :myself range) oder durch eine Hash-Funktion (für lokale DFOs typischerweise zufällig). [DFO_self] wird daher unterschiedliche Werte innerhalb unterschiedlicher DFOs aufweisen. ii. Der Adressbereich wird typischerweise eine einzelne IPv6 Adresse sein. Ansonsten wird die Hash-Funktion eine geeignete Adresse innerhalb des Bereichs auswählen. iii. Die Adresse [DFO_parent] von ‘parent’ (hier [DFO₁]) ist an eine geeignete vordefinierte globale Variable gebunden. Der Term ‘global’ bedeutet global innerhalb des neu gebildeten DFOs. iv. Die Ergebnisse der Evaluierung innerhalb DFO₂ des Evaluierens der Argumente an das (dfo-create ...). v. Die Argumente können einen Port setzen, auf welchem der Übergeordnete einen Code S zur beliebigen Ausführung kommuniziert sowie den initialen Firewall Code. vi. Die Argumente setzen typischerweise den Port, an welchem der Übergeordnete (parent) den zurückgegebenen Wert (evaldfo-2 S) akzeptieren wird. Der Port ist typischerweise der gleiche Port, wie direkt oberhalb.
• d. Die Firewall von DFO₂ ist typischerweise mit initialen Berechtigungen eingerichtet, welche die Injektion von Code und Daten in das DFO_created durch DFO_creating erlauben. Diese Injektion erfolgt typischerweise in irgendeinen Port (möglicherweise Port 0). Der injizierte Code wird danach ausgeführt und typischerweise ist ein Nebeneffekt der Ausführung, dass auf einigen Sätzen von Ports (möglicherweise Port 0) die Werte verfügbar gemacht werden, welche von der Berechnung des injizierten Codes erlangt wurden.

The newly formed DFO typically returns at least one value within the environment of the first DFO (DFO ₁ ), which is the address and communication port [DFO _created ]: port of the formed DFO, in this example, DFO _created . This allows the higher level DFO to communicate with the newly formed lower level DFO.

• b. One of the possible arguments for invoking a new DFO (named as above "dfo-create") is the specification of a communication port over which DFO _created expects to exchange messages with DFO _creating . One possible implementation is (dfo-create: comport-in value1: comport-out value2 rest-of-args) which can be abbreviated (dfo-create: comport value ...) if value1 is value2. This communication port is typically zero for local DFOs, but must be specified for DFOs that can be accessed externally.
• c. Evaluating the arguments (dfo-create args) typically involves the following steps: i. DFO2's IPv6 address [DFO _self ] is set either by specifying an address range (dfo-create: myself range) or by a hash function (typically random for local DFOs). Therefore, [DFO _self ] will have different values within different DFOs. ii. The address range will typically be a single IPv6 address. Otherwise, the hash function will select a suitable address within the range. iii. The address [DFO _parent ] of 'parent' (here [DFO ₁ ]) is bound to an appropriate predefined global variable. The term 'global' means globally within the newly formed DFO. iv. The results of the evaluation within DFO ₂ of evaluating the arguments to the (dfo-create ...). v. The arguments can set a port on which the parent communicates a code S for arbitrary execution as well as the initial firewall code. vi. The arguments typically set the port where the parent will accept the returned value (evaldfo-2 S). The port is typically the same port as directly above.
• d. The firewall of DFO ₂ is typically set up with initial permissions that allow injection of code and data into the DFO _created by DFO _creating . This injection is typically done in any port (possibly port 0). The injected code is then executed and typically a side effect of the execution is that on some sets of ports (possibly port 0) the values obtained from the calculation of the injected code are made available.

• e. Aufgrund des direkt vorangehenden Absatzes wird DFO_i typischerweise S akzeptieren und anschließend evaluieren, welches von [DFO_creating] stammt und auf [DFO_created]:parent erhalten wurde.
• f. DFO₁ injiziert Initialisierungscode in DFO₂
• g. Dieser Initialisierungscode wird ausgeführt (wird evaluiert) durch DFO₂.
• h. Das Ergebnis der Evaluierung wird auf dem spezifizierten Ausgangs-Port präsentiert.

Note: Before evaluating the arguments to (dfo-create ...), the environment is the default environment; therefore, any code injected by DFO ₁ into DFO ₂ and accepted for execution provides predictable results. It would be unusual, but still possible with the arguments to (create-dfo args), that a DFO refuses or does not evaluate expressions sent by DFO _parent to the specified port. This capability would be useful in operating independent parallel processing systems.

• e. Due to the preceding paragraph, DFO _{i will} typically accept and then evaluate S, which originates from [DFO _creating ] and was obtained on [DFO _created ]: parent.
• f. DFO ₁ injects initialization code in DFO ₂
• G. This initialization code is executed (evaluated) by DFO ₂ .
• H. The result of the evaluation is presented on the specified output port.

3. NEWS FORMATS

• a. Typically, messages from one DFO are forwarded to another as executable objects, such as LISP S expressions.
• b. Therefore, a DFO can set any variable (as far as allow permissions) in another DFO, simply by passing a message (SETF value in variable form).
• c. Setting a variable in another DFO can be implemented by a function such as (dfo-send address args). The syntax for setting the variable 'color' to 'red' can be as simple as follows (dfo-send DFO (SETF color red))

4. DFO communication reliability

Communications between different DFOs using IPv6 as a transmission protocol are probabilistic. That is, a message sent from one [DFO] will be routed to another [DFO], however, as with both IPv4 and IPv6 protocols, messages may take an arbitrarily long time or be completely dropped. IPv6 options, such as lifetime fields, are used to control the timing and continued existence of inter-DFO communications. A DFO that requires high reliability of communication implements a protocol such as TCP, where acknowledgment and acknowledgment messages indicate successful transmission and reception.

According to the second aspect, there is provided a computer implemented data fusion object, DFO, capable of communicating with at least one other DFO over a communication network (N), the communication network (N) providing a number of available network addresses, each DFO has a separate and independent address on the communication network.

• – in einer externen Rechnerumgebung zu existieren;
• – einen Ausdruck-Evaluierer zu implementieren;
• – zumindest eine Adresse aufzuweisen, welche es für eine Kommunikation innerhalb der Umgebung identifiziert, und
• – eine interne Rechnerumgebung zu umfassen mit vorbestimmten Verfahren und Eigenschaften,
• – in der Lage zu sein, neue Verfahren und neue Datenstrukturen seiner internen Rechnerumgebung hinzuzufügen, und in der Lage ist: neue DFOs innerhalb seiner Umgebung zu bilden; neue DFOs innerhalb seiner Umgebung zu zerstören; und mit DFOs innerhalb seiner internen Umgebung oder innerhalb der externen Umgebung zu kommunizieren.

where the DFO is adjusted to:

• - to exist in an external computing environment;
• To implement an expression evaluator;
• To have at least one address identifying it for communication within the environment, and
• To include an internal computing environment with predetermined methods and properties,
• - be able to add new procedures and new data structures to its internal computing environment, and be able to: create new DFOs within its environment; to destroy new DFOs within its environment; and to communicate with DFOs within its internal environment or within the external environment.

The DFO may further comprise an internal computing environment comprising at least one other DFO as defined above.

Here, a predetermined method is a computer process which implements a predetermined function whose input data are characteristics of the DFO and whose evaluation modifies an inner state of the DFO.

Here, the method is capable of causing formation or destruction of one or more DFOs and causing communication of data and environment to at least one other DFO and communicating data over a communication network.

Here, properties are represented as data and data is evaluated as a method.

• – von anderen DFOs deren interne Rechnerumgebung zu empfangen und diese empfangene Umgebung zu verwenden, um Verfahren des sendenden DFOs und Verfahren, welche dem empfangenden DFO innewohnen, zu berechnen
• – und in der Lage ist, zu evaluierende Ausdrücke und Daten für diejenigen Ausdrücke von anderen DFOs zu empfangen unter Verwendung entweder einer empfangenen Umgebung oder der internen Umgebung des empfangenden DFOs.

Here, methods are used as data when passed to a DFO, and data are methods when they are received by a DFO and deconstructed to implement methods so that the DFO is able to:

• Receive from other DFOs their internal computing environment and use this received environment to compute methods of the sending DFO and procedures inherent in the receiving DFO
• And is able to receive terms and data to evaluate for those terms from other DFOs using either a received environment or the internal environment of the receiving DFO.

The DFO can be implemented in hardware and / or in logical software.

Here are inputs to the DFO and outputs from the DFOs packets sent and received using network addresses.

The DFO may be adapted to send messages to a second DFO by sending a set of IP packets to a predetermined port and / or receiving messages from the second DFO by receiving packets from a predetermined port of the second DFO.

The DFO addresses can be in the format of an IPv6 procedure and the DFO's procedure and data transport mechanisms are implemented in IPv6 specifications and using TCP / IP protocols.

Also, according to the second aspect, there is defined a system for evaluating calculable functions, the system comprising at least one DFO as defined above.

Also defined according to the second aspect is a computable evaluation function having means for local or parallel functional evaluation, filtered data input and output, and process-dependent input and output of one or more encapsulated functional objects to other such objects and for computer and data processing devices and systems which are located locally or on the Internet, the method being carried out by the previously defined system.

QUOTES INCLUDE IN THE DESCRIPTION

This list of the documents listed by the applicant has been generated automatically and is included solely for the better information of the reader. The list is not part of the German patent or utility model application. The DPMA assumes no liability for any errors or omissions.

Cited patent literature

• WO 2015/066527 [0013]

Cited non-patent literature

• Version 4 of RFC 4122 of the Network Working Group, July 2005 [0003]
• Version 4 of RFC 4122 ("Leach Salt") and Version 5 of RFC 4122 (SHA-1 hash over a namespace) [0004]
• 2008 by the pseudonyms Satoshi Nakamoto in the paper titled "Bitcoin: A Peer-to-Peer Electronic Cash System" [0005]
• Generally, these schemes are not strictly in accordance with RFC 2460, Internet [0054]

Claims (11)

A method of data communication and computation over a network, wherein nodes of the network are capable of evaluating functions in the local environment of the node, and wherein the addresses of newly formed or newly connected network nodes are randomly assigned, with a near uniqueness of the nodes Addresses are achieved by using a random or pseudo-random method of selecting an address from a sufficiently large pool of network addresses. The method of claim 1, wherein no node or collection of nodes in a network or subnet stores the network addresses or identifier of all other nodes in memory, although a node stores the addresses of nodes formed under its supervision, or store the addresses of those nodes that have formed it or store the node addresses supplied to it by another node in memory. The method of claim 1 or 2, wherein the network is divided into two or more sub-networks, with a gateway between the sub-networks over which data can be sent to another sub-network, and wherein the gateway is a non-random address is assigned on at least one side of the gateway, which is connected to one or more of the multiple sub-networks, but not containing the sub-network in which the method is used according to claim 1, wherein the at least one address by one or more fixed Addresses is determined, or by addresses, which are determined by a fixed property of the node in the sub-networks on the pages of the gateway, in which the method is not used according to claim 1 to assign addresses. A method according to claim 1 or claim 2 or claim 3, wherein the network is divided into two or more sub-networks, with a gateway between the sub-networks over which data can be sent to another sub-network, and the gateway a non-random address is assigned on at least one side of the gateway, which is connected to one or more of the multiple sub-networks, but not containing the sub-network in which the method is used according to claim 1, wherein the at least one address by determining a server which is distinguishable from the node for which an address is determined, the server determining the network addresses from those nodes which do not yet have a network address. The method of claims 1-4, wherein the uniqueness of the node address is ensured by a broadcast message from a sending node requesting an acknowledgment message sufficient to identify the address of the sending node and which are transmitted through the network or through the network Subnet is transmitted in which the node is located and by, on receiving an acknowledgment message, reassigning, again with a random selection, the network address of either the sending node or the receiving node or both. Method according to claims 1-4, applied to an existing network with a method for adding newly formed nodes to addresses so that uniqueness of the new address is ensured by a broadcast message originating from the newly formed node (the "sending") Node), the send message containing a data packet requesting from each receiving node an acknowledgment message sufficient to identify the address of a network node that conflicts with or duplicates that of the sending node, the duplicate node Broadcast message and response message are transmitted through the network or subnet in which the sending node is located and, upon receiving an acknowledgment message indicating that an existing node has this address, the sending node Apoptosis triggers, with the sending node as result is removed therefrom from the system, wherein an error is returned to the process which has formed the sending node, the broadcast message consisting of an address specifying a broadcast message and a data portion containing a possibly different matching address such that each node receiving the broadcast message checks the address for correspondence and, if it matches the address of the node receiving the broadcast, sends a return message indicating that this address is already through the networks in use. A method according to claims 1-4, wherein the uniqueness of a newly formed node address is ensured by a broadcast message from a newly formed node (the "sending node") requesting an acknowledgment message sufficient to address a network node identify which is conflicting with that of the sending node or that of the sending node Node is duplicated, whereby the acknowledgment message is transmitted through the network or subnet in which the node is located and, upon receiving an acknowledgment message indicating that another node has this address, the sending node As a result, the sending node is removed from the system, and an error is returned to the process that formed the sending node. The method of claims 1-4, wherein the formed nodes exchange messages according to a well-defined layer protocol, such as TCP or UDP, such messages being sent to existing nodes to cause the existing nodes to form new nodes in order to create nodes. Induce apoptosis to relay network traffic and to evaluate computational procedures. The method of claim 8, wherein a node in a network maintains an internal state, and wherein within that state there is an environment containing the value and functional bindings of internal state variables, such as values or function names or function definitions, and within the environment functions can be evaluated together with a method of communication as described in claims 6 and 7, so that a function can be presented together with its functional domain to the node at its node address and the evaluation of this function together with its environment of the Node can be retrieved. The method of claim 9, wherein the functions to be evaluated are presented to the node on particular ports, and the evaluations of the functions are presented to other nodes on particular ports designated for that purpose. A method according to claim 9 or claim 10, wherein functions to be evaluated are presented in the format of the lambda calculus in a variable-free manner using indices of occurrence and by forming links between numbers of occurrences and arguments of the functions with appropriate data locking on the links ,

Images