KR20050003430A - Cooperation of concurrent, distributed networks of resources - Google Patents

Abstract

Programs (324, 320) are disclosed that include expressions written in a process based language to represent a protocol based application as a process. Process kernels 320C, 306C, 304C, and 308C execute expressions in the program. This expression is exchanged as a process between processes in which a named organizational scheme of data written in customizable tag-based languages 302, 304, 306, and 308 sends and receives this named data organization. By specifying the interaction of processes.

Description

Collaboration of Parallel Distributed Resource Networks {COOPERATION OF CONCURRENT, DISTRIBUTED NETWORKS OF RESOURCES}

Natural language, unlike programming or machine language, is a language spoken and written by humans. A programming language is any artificial language that can be used to define a series of instructions that can ultimately be processed and executed by a computer. Defining what is a programming language and what is not can be tricky, but a common use is that the process of translating from source code expressed using a programming language into machine code, which is the code that the computer needs to use to operate, is another such as a compiler. Means that it is automated by the program. Both natural and programming languages are systematic means of conveying information and instructions from one entity, such as person to person or person to machine, to another. However, conventional programming languages have been an incomplete way of conveying information and instructions from humans to machines.

For example, in the early days of the computer age, assembly language was used to form low-level programming languages. Assembly language uses abbreviations or mnemonic codes where each statement corresponds to a machine instruction. In addition to the high efficiency benefits of direct programmer interaction with system hardware and resources, there are undesirable consequences of manually updating temporary constructs such as data structures when minor changes are made to assembly language programs. Today's high-level languages, which provide a level of abstraction on top of the underlying machine language, have evolved from assembly language. High-level language statements usually use keywords (usually in English) that are translated into two or more machine instructions. High-level languages have built-in support for data structures and define a set of syntactic and semantic rules that define the structure of the language. When small changes are made to a program written in a high-level language, a compiler that converts the program into object code by following a predetermined set of syntactic and semantic rules will ripple the object code as needed to match the changes made to the program. Reflow or rather notify the programmer of an obvious programming error.

The programmer uses the compiler's functionality to detect errors in invocations of the API by checking the signature of the calling application programming interface (API) against the corresponding signature of the defined API. An API is an interface for a program that defines the type of input that the program will accept to perform the desired task and the type of output that the program will return after performing the desired task. APIs allow programs to collaborate with each other to provide more functionality than each can provide on its own.

The API does not specify the behavior of the program that underlies the API, but merely specifies what must be provided to the API and what is returned from the API. For example, in order to cooperate properly, the "initialization" program must be called before the "do work" program is called, and in response, the "work execution" program is called "clean up". "It must be called before the program is called. The API does not capture this ordering concept or any other concept that expresses how the program should cooperate. As a result, like the hard work of maintaining old assembly programs, programmers have to work hard once again by working within the limits of expressiveness of current high-level languages to ensure that programs work correctly.

The problem is exacerbated by the proliferation of web services, which are basically programs on any number of computing devices interconnected by the Internet. On the other hand, although painstaking designation and intensive validation of the collaboration of programs within one computing device can be undertaken, the complex ballet associated with the collaboration of multiple web services (sending multiple messages from multiple computing devices) can be undertaken. Ballet verification is a difficult problem to overcome due to the lack of expressiveness of current high-level languages. Among them, a programming language that can express such a cooperative dimension is needed so that the cooperative dimension of a program or service such as order and timing can be programmatically verified.

One partial solution is the use of π-calculus, a mathematical language for describing processes in interactive parallel systems, such as the system 100 shown in FIG. System 100 includes a client 102, which is a computer that accesses shared network resources provided by another computer, such as server 106 on a local area network or a telecommunications network, such as the Internet 104. A number of web services 108, 116 are stored statically as programs on the client 102 and the server 106.

Early operating systems allowed users to run only one program at a time. The user ran the program, waited for it to complete, and then ran another program. Modern operating systems allow a user to simultaneously run (run) two or more programs or even multiple copies of the same program at a time. Threads are the basic units used by the operating system to allocate processor time to programs. A thread can contain any part of programming code, including the part currently being executed by another thread. The processor can only run one thread at a time. However, a multitasking operating system, ie an operating system that allows a user to execute multiple programs, appears to run multiple programs simultaneously. In practice, a multitasking operating system can run back and forth between programs, running threads from one program, then threads from another program, and so on. When each thread completes its subtasks, the processor receives another thread to execute. The tremendous speed of the processor creates the illusion that all threads are running at the same time.

The terms multi-tasking and multi-processing can sometimes be used interchangeably, but they have different meanings. Multi-processing requires multiple processors. If the machine has only one processor, the operating system can multi-task but not multi-processing. If a single machine has multiple processors or there are multiple machines each with a processor (client 102 and server 106), the operating system of a single machine or the operating system of multiple machines may be multi-tasking and Both multi-processing can be done. Both a single machine with multiple processors and multiple machines each with processors define a concurrent system. This is of interest for the π-operation structure.

The core of the π-operation structure consists of a system of independent parallel processes (web services 108, 116, etc.) that communicate over a link (such as link 124). Links are the following: APIs that act as remote procedure calls, hypertext links that can be created, passed, and removed, and object references passed as arguments of method calls in an object-oriented system (eg, "rose" ) "). The possibility of communicating with other processes in the process depends on the knowledge of the different links. The link can be restricted so that only certain processes can communicate through it. What distinguishes the [pi] -operation from other process languages is that the scope of the restriction (the context in which the link can be used) can change during execution. For example, when the web service 116 sends a restricted name, such as an API, that the web service 116 only knows in advance, as a message to the web service 108 that is outside the limits, the range is extended (or π Protruding from the mathematical idiom of the computational structure). This means that the scope of the API is expanded to encompass the web service 108 that receives the API. In other words, the web service 108 can now call the function represented by the API, but previously the web service 108 did not know about the API and thus could not call the API. This procedure allows the communication possibilities of the process to change over time within the framework of the π-operation structure. The process can know the names of the new links through scope extrusion. Thus, the link represents a transferable quantity for improving communication.

Central, basic and unchanging with respect to the π-operational structure is the conveying of its strong concentration and name for names such as "roses" as messages via links. In particular, the π-operation structure places great emphasis on pure names, each of which is defined as just a bit pattern. One example of a pure name is a 128-bit spatial Globally Unique Identifier (GUID) that uniquely identifies an interface or implementation in the COM component model. Another example of a pure name is a function signature or API as described above. To further emphasize, consider the above problem in this respect. There are three APIs sent from web service 116 to web service 108 ("initialization", "task execution", and "cleanup"), but web service 116 only needs to see these three APIs in a specific order ( For example, suppose that you need to call "Initialize" followed by "Execute Task" followed by "Cleanup". The existing π-operation structure and variations thereof allow three APIs to be transmitted over the link 124 to reach the web service 108 from the web service 116, but the existing π-operation structure and its In a variation, there is no way for the web service 116 to express the specific order in which three APIs are called for the web service 108. In this respect, the existing [pi] -operation structure and its variations do not fully express such cooperative dimensions such that, in particular, the cooperative dimensions of programs or services such as order and timing can be programmatically verified.

A Queen Elizabeth's poet succinctly provided the following proverb, embodying a metaphorical but timeless observation in form. "What's in the name? If we call the rose any other name, it will smell like candy." This observation, made long ago, pinpoints the current problem of π-operational structures and their modifications—the lack of tolerance for the transfer of structured data over named links (such as link 124). In practice, the π-operations unfortunately call structured data "negative names", which are negative linguistic structures. Purity is desirable but hates impurity. Thus, an impure name in the context of a π-operation structure is data having some sort of recognizable structure, such as an extensible markup language (XML) document. In fact, it is useful (sometimes necessary) for one process to pass structured data to another process.

Without the flow of data, it is difficult to facilitate communication between processes (except in very indirect ways) to indicate mobility or dynamics between processes. To solve this problem, computer scientists explored the possibility of allowing a process to be moved during communication over a link. For example, process 110 may send a message to process 118 indicating a third process (not shown). This is called higher-order π-calculus. Due to the strictness of the π-operational structure in handling pure names, no names are sent over the link, and even higher order π-operational variants do not transmit the process itself, but instead provide a name that provides access to the desired process. send.

Sending a name instead of a process is analogous to a conventional technique of passing by parameter using the address of a parameter to retrieve or modify the value of the parameter, that is, the address of the parameter from the calling routine to the called routine. Can be. The main problem with using the reference transfer technique in higher order π-operational structures is that the technique can prevent parallel systems from becoming decentralized. There are many implementations of the π-operational structure, among others, in particular PICT, Nomadic PICT, TyCO, Oz and Join. However, these other implementations are neither distributed π-operated structures (PICTs) nor high-order π-operated structures (nomadic PICT, TyCO, Oz and Join).

Accordingly, there is a need for a better method and system that allows processes in a parallel distributed computing network to interact while avoiding or reducing the above and other problems associated with existing [pi] -operation structures and variations thereof.

Cross Reference of Related Application

This application is incorporated herein by reference in U.S. Provisional Application No. 60 / 379,864, entitled "Process Programming Language," filed May 10, 2002, which is expressly incorporated herein by reference. US Patent Application No. 10 / 303,407, entitled "Process Kernel", filed November 22, 2002, which is expressly incorporated herein by reference, which is expressly incorporated herein by reference. No. 10, filed November 22, 2002, entitled " Permutation Nuances of the Integration of Processes and Queries as Processes at Queues. &Quot; / 303,445, filed November 22, 2002, which is expressly incorporated herein by reference, is entitled "Structural Equivalence of Expressions Including Processes and Queries (St ructural Equivalence of Expressions Containing Processes and Queries, and U.S. Patent Application No. 10 / 303,379, and the name of the invention filed November 22, 2002, which is expressly incorporated herein by reference, refers to "a query as a processor." Priority is claimed in US Patent Application No. 10 / 303,343, "Operational Semantics Rules Governing Evolution of Processes and Queries as Processes".

TECHNICAL FIELD The present invention relates generally to networked computers and, more particularly, to a method of causing collaboration of a parallel, distributed network of computing resources.

Most of the above aspects and ancillary advantages of the present invention will become more readily apparent as the present invention is better understood with reference to the following detailed description set forth in connection with the accompanying drawings.

1 is a block diagram illustrating a conventional parallel system for transmitting a name of an API or the like through a link between two web services using a π-operation structure.

2 is a block diagram illustrating an exemplary computing device.

3A-3C are block diagrams illustrating an exemplary parallel distribution system formed in accordance with the present invention for transferring structured messages between multiple processes.

4 is a block diagram illustrating the main syntax categories of an exemplary programming language, which is an artificial language that can ultimately be used to define a set of instructions that can be processed and executed by an exemplary computing device within a parallel distributed network of computing resources.

5 is a block diagram illustrating in more detail an exemplary queue formed in accordance with the present invention for storing a process as a message for transfer between two processes.

6A and 6B are block diagrams illustrating techniques for determining structural equivalence between two programmatic documents formed in accordance with the present invention.

7A and 7B are block diagrams illustrating a technique for fusing two queues to enhance communication between two processes in a parallel distributed system formed in accordance with the present invention.

8 is a block diagram illustrating an exemplary system formed in accordance with the present invention for fusing two queues in a parallel distributed system formed in accordance with the present invention to enhance communication between processes.

9A and 9B are block diagrams illustrating an exemplary system that allows two separate processes to communicate in a parallel distributed system formed in accordance with the present invention by shortening two database types.

10A-10C are block diagrams illustrating exemplary systems formed in accordance with the present invention for discovering names by which processes may be used to access multiple databases in a parallel distributed system formed in accordance with the present invention.

11A-11V are method diagrams illustrating an exemplary method formed in accordance with the present invention for compiling a program by a compiler or executing a process through a process kernel.

According to the present invention, a system, method and computer readable medium for processing a program written in a process based language are provided. The present invention in the form of a system includes computer readable means for storing a program. The program includes expressions written in a process based language to represent protocol based applications as processes. The system also includes a process kernel that executes the expression in the program. The expression specifies the interaction of processes by allowing named data organizational schemes written in a customizable tag-based language to be exchanged as processes between processes. The named data organization method is bound to the scope of processes for transmitting and receiving the named data organization method.

According to another aspect of the invention, the invention in the form of a method is embodied in a computer system. The method includes presenting a protocol based application as a process when a process expression in a program written in a process based language is executed. The method also includes expressing, as a process, a method of constructing named data written in a customizable tag-based language when a query expression is executed. The method includes causing processes to communicate when processes send or receive from the queue as a query the named data organization. The named data organization method is bound to the scope of processes for transmitting or receiving the named data organization method.

According to another aspect of the invention, another system form of the invention includes a query virtual machine that defines a query in a program written in a process based language and governs the interaction between the query and the queue. The system also includes a process virtual machine that defines a process comprising protocol based applications in the program and governs the interaction between the processes. The system further includes a reactive virtual machine that defines valid interactions between queries, queues, and processes, and also governs interactions between queries, queues, and processes by interpreting queries as processes.

According to the present invention, a method and a computer readable medium for processing a program written in a process based language are provided. According to the present invention, the present invention in the form of a method comprises parsing the expression to obtain a syntax element representing a queue, a set of queue delimiters, a query, a sequence delimiter, and other actions. do. The method includes interpreting the expression as a process in which the first action sends the query to the queue as another process and then continues with another action. The query includes a configuration scheme formed from a customizable tag-based language that contains data and describes the data.

According to one aspect of the invention, the invention is provided in the form of a method of executing a set of equation laws that govern the structural equivalence of an expression written in a process based language. The method parses the first expression. The first expression describes that the query is running in parallel with the process. The query has a body that includes an empty head and a first name bound to a second name. The method interprets the first expression as being structurally equivalent to the second expression. The second expression describes that the query is executed in parallel with the process when the query is in canonical form. Each occurrence of the first name in the process is replaceable with the second name.

According to the present invention, a method and a computer readable medium for processing a program written in a process based language are provided. The present invention is provided in the form of a method of executing a series of operational semantics rules that govern the meaning of expressions written in a process based language. The method includes parsing the first expression. The first expression describes that the process is a choice of two processes. The first of the two processes expresses that a first query is sent to a queue, after which the first process continues a first series of operations. The second of the two processes expresses that a second query is sent to the queue, after which the second process continues a second series of operations. The method further includes reducing the first expression to a second expression. The second expression describes that the third query is sent to the queue when a third query is in standard form, after which the first process is executed in parallel with the second process.

According to another aspect of the present invention, another method is provided for executing a set of operational semantic rules that govern the meaning of expressions written in a process based language. The method includes parsing the first expression. The first expression describes a first process and the first operation of the first process is to send a query to the queue, after which the first process continues the second process. The method further includes the step of abbreviating the first expression to a second expression. The second expression describes that the lifted query is executed in parallel with the second process when the first query is in standard form.

2 illustrates a suitable computing system environment 200 for implementing certain aspects of the present invention, such as processing queries, queues, and processes generated in accordance with the present invention, and / or executing a process kernel described later. ) Shows an example. The computing system environment 200 is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Computing environment 200 should not be construed as having any dependency or requirement with respect to any one or combination of components shown and described.

The present invention operates in many other general purpose or special purpose computing system environments or configurations. Examples of known computing systems, environments and / or configurations that may be suitable for use with the present invention include personal computers, server computers, handheld or laptop devices, multiprocessor systems, microprocessor based systems, set top boxes, programmable Home appliances, network PCs, minicomputers, mainframe computers, distributed computing environments including any of the above systems or devices, and the like.

The invention is described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types.

The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

The computing system environment shown in FIG. 2 includes a general purpose computing device in the form of a computer 210. Components of the computer 210 may include, but are not limited to, a system bus 221 that couples various system components, including the processing unit 220, the system memory 230, and the system memory to the processing unit 220. no. The system bus 221 can be any of several types of bus structures, including a memory bus or a memory controller, a peripheral bus, and a local bus using any of a variety of bus architectures. By way of example, and not limitation, such bus architectures may also be referred to as an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a mezzanine bus. There is a Peripheral Component Interconnect (PCI) bus.

Computer 210 generally includes a variety of computer readable media. Computer readable media can be any available media that can be accessed by computer 210 and includes both volatile and nonvolatile media, removable and non-removable media. By way of example, and not limitation, computer readable media may comprise computer storage media and communication media. Computer storage media includes both volatile and nonvolatile, removable and non-removable media implemented in any method or technology for storage of information such as computer readable instructions, data structures, program modules or other data. Computer storage media include RAM, ROM, EEPROM, flash memory or other memory technology, CD-ROM, DVD or other optical disk storage device, magnetic cassette, magnetic tape, magnetic disk storage device or other magnetic storage device, or any other Computer storage media include, but are not limited to. Communication media generally embody computer readable instructions, data structures, program modules or other data in modulated data signals, such as carrier waves or other transmission mechanisms including any information transfer media. The term "modulated data signal" means a signal that has one or more of its characteristics set or changed in such a manner as to encode information in the signal. By way of example, and not limitation, communication media include wired media such as wired networks or direct wired connections, and wireless media such as acoustic, RF, infrared, and other wireless media. Combinations of any of the above should also be included within the scope of computer readable media.

System memory 230 includes computer storage media in the form of volatile and / or nonvolatile memory, such as read only memory (ROM) 231 and random access memory (RAM) 232. Basic input / output system 233 (BIOS), which includes basic routines to assist in the transfer of information between components within computer 210, such as during startup, is generally stored in ROM 231. RAM 232 generally includes data and / or program modules that are directly accessible by and / or presently being processed by processing unit 220. As a non-limiting example, FIG. 2 illustrates operating system 234, application program 235, other program module 236, and program data 237.

Computer 210 may also include other removable / non-removable, volatile / nonvolatile computer storage media. By way of example only, FIG. 2 illustrates a hard disk drive 241 that reads from or writes to non-removable, nonvolatile magnetic media, a magnetic disk drive 251 that reads from or writes to a removable, nonvolatile magnetic disk 252, and An optical disc drive 255 is shown for reading from or writing to a removable, nonvolatile optical disc 256, such as a CD-ROM or other optical medium. Other removable / non-removable, volatile / nonvolatile computer storage media that can be used in the exemplary operating environment include, but are not limited to, magnetic tape cassettes, flash memory cards, DVDs, digital video tapes, solid state RAM, solid state ROM, and the like. It is not. Hard disk drive 241 is generally connected to system bus 221 via a non-separable memory interface, such as interface 240, and magnetic disk drive 251 and optical disk drive 255 are generally interface 250. It is connected to the system bus 221 by a separate memory interface, such as.

The drive described above and shown in FIG. 2 and its associated computer storage media provide storage of computer readable instructions, data structures, program modules, and other data of computer 210. In FIG. 2, for example, hard disk drive 241 is shown to store operating system 244, application program 245, other program modules 246, and program data 247. Note that these components may be the same as or different from operating system 234, application program 235, other program module 236, and program data 237. The operating system 244, the application program 245, the other program module 246, and the program data 247 are assigned different numbers at least to indicate that they are different copies. A user may enter commands and information into the computer 210 through input devices such as a keyboard 262 and a pointing device 261, which is commonly referred to as a mouse, trackball, or touch pad. Other input devices (not shown) may include a microphone, joystick, game pad, satellite dish, scanner, or the like. These and other input devices are often connected to the processing unit 220 via a user input interface 260 connected to the system bus, but by other interfaces and bus structures, such as parallel ports, game ports, or Universal Serial Bus (USB). Can be connected. The monitor 291 or other type of display device is also connected to the system bus 221 via an interface such as a video interface 290. In addition to the monitor, the computer may also include other peripheral output devices, such as a speaker 297 and a printer 296, which may be connected via the input / output peripheral interface 295.

Computer 210 may operate in a networked environment using logical connections to one or more remote computers, such as remote computer 280. Remote computer 280 may be a personal computer, server, router, network PC, peer device, or other conventional network node, although computer memory generally is shown in Figure 2, although only memory storage 281 is shown in FIG. In connection with most or all of the above components. The logical connection shown in FIG. 2 includes a local area network (LAN) 271 and a wide area network (WAN) 273, but may also include other networks. Such network environments are commonplace in offices, enterprise-wide computer networks, intranets and the Internet.

When used in a LAN networking environment, the computer 210 is connected to the LAN via a network interface or adapter 270. When used in a WAN networking environment, computer 210 generally includes a modem 272 or other means for establishing communications over WAN 273, such as the Internet. The modem 272, which may be internal or external, may be coupled to the system bus 221 via an input / output peripheral interface 295 or other suitable mechanism. In a networked environment, program modules described in connection with the computer 210 or portions thereof may be stored in a remote memory storage device. As a non-limiting example, FIG. 2 illustrates remote application program 285 as present on memory device 281. It will be appreciated that the network connections shown are merely exemplary and that other means for establishing a communication link between the computers can be used.

System 300, which is a collection of component components that work together to perform one or more computing tasks, is shown in FIG. 3A. One example is a personal digital assistant (PDA) 302, cellular telephone 334, and desktop computer 336, each of which includes a microprocessor, its associated chips and circuits, input and output devices, and peripherals (not shown). Hardware system 344, which may include a number of computing devices, such as < RTI ID = 0.0 > For convenience of explanation, the only computing device shown in the following figures is a personal digital assistant (PDA).

System 300 includes an operating system 342 that includes a series of program and data files, such as operating system kernel 303A, one or more device drivers 303B, and a process kernel 302C. A hardware abstraction layer 301 is connected below the operating system 342. Hardware abstraction layer 301 is an application programming interface for use by a programmer to access devices of hardware system 344 (such as computing device 302, cellular telephone 334, and desktop computer 336). Operating system kernel 303A is the core of operating system 342 and manages memory, files, and peripherals (via hardware abstraction layer 301), maintains time and date, web services 302A, and the like. It is designed to launch applications and allocate system resources. Device driver 303B is a separate component that enables web service 302A to communicate with a device, such as computing device 302. Process kernel 302C represents web service 302A as process 302B, manages process 302B, and facilitates communication with other processes in process 302B (described below). Operating system kernel 303A, device driver 303B, and process kernel 303C reside in the kernel mode portion of operating system 342, while web service 302A and process 302B operate on operating system 342. In the user mode portion 346 of the. In another alternative, when process kernel 303C is connected to the bottom of other system software components 305 and 307 (FIG. 3B), such as Component Object Model (COM), process kernel 303C may be a user mode portion ( 346).

The term "process" as used in accordance with the present invention refers to a dynamic representation of one or more computational entities that have the ability to evolve by performing an action or enable other processes to evolve. In other words, the term "process" refers to one of the dual characteristics of a computing entity. If the computing entity is resting, that entity can be checked by program view or the like. If a computing entity is operating (as a process), it cannot see the entity but its behavior can be represented and verified by a programming language 400 formed in accordance with the present invention (described below).

Web service 302A is designed to be dedicated to any service. To achieve more functionality, web service 302A may benefit from other web services that may provide services that are not within the scope of web service 302A. To find other web services, the web service 302A may communicate with the directory framework 326. Directory framework 326 is platform-independent software (directory framework) that provides a method for finding and registering web services on the Internet. Directory framework 326 includes a repository 330 that includes a number of registered web services and contains detailed technical information about these web services. The discovery component 328 of the directory framework 326 serves as an intermediary between the process 302B and the repository 330 to find the desired web service.

Once the directory framework 326 finds the appropriate web service requested by the web service 302A, the web service 302A may begin interacting with the found web service to achieve the desired task. 3B shows the discovered web service 304A. Process kernel 304C represents web service 304A as a process 304B that interacts with process 302B via communication means such as queue 310 to accomplish the tasks of web services 302A, 304A. .

The queue 310 through which the processes communicate there may take many forms, such as a database, channel, or other suitable structured repository. Since computing devices 302 and 304 may be located in geographical locations remote from each other, processes 302B and 304B may not communicate through shared memory. Suitable communication means, such as queue 310, include techniques that enable processes 302B and 304B to communicate over heterogeneous networks and systems that may be temporarily offline while running at different times. Processes 302B and 304B send messages to and read messages from the communication means. The communication means may provide guaranteed message delivery, efficient routing, security, and priority based messaging. In addition, communication means can be used to implement solutions for both asynchronous and synchronous scenarios that require high performance. As mentioned above, specific examples of suitable means of communication include channels, queues, or databases, among other structured repositories. If the queues 310-316 are databases, they are files of records, each record containing fields with a series of actions for search, sort, recombine, and other processing functions, each consisting of multiple tables, The table of is a data structure consisting of rows and columns, with the data occupying or perhaps occupying each cell formed by a row-column intersection.

The internal architecture of process kernels 302C and 304C defines process virtual machines 302C1 and 304C1, which contain software components that define processes and govern interactions between processes, define queries and govern interactions between queries and queues. Query virtual machines 302C3 and 304C3, which include software components, and reactive virtual machines 302C2 and 304C2, which include software components that govern the interaction between queries, queues, and processes, and process kernels 302C and 304C. Transition virtual machines 302C4, 304C4 that include software components that separate from the details of system software components 305, 307 (especially COM and operating systems, etc.) on computing devices 302, 304.

Computing devices 302 and 304 interact, communicate, and exchange information over local area network, telecommunication network, or wireless network 338. Processes 302B and 304B communicate via queue 310 to exchange messages, such as message 318. Unlike conventional systems that implement the π-operation structure and variations thereof, system 300 formed in accordance with the present invention is a process kernel 302C, 304C in which messages such as message 318 are exchanged between processes 302B, 304B. To be represented as a process. This allows, among other things, a cooperative dimension of a program or web service, especially the calling order of APIs, to be expressed between processes 302B and 304B.

3C illustrates a number of computing devices 302, 304, 306, 308 that can communicate the system 300 with one another and appear to the user as one large accessible " storehouse " of shared hardware, software, and data. It is shown as a non-central network that includes). System 300 is a distributed system that is conceptually the opposite of a centralized or monolithic system in which a dumb client is conceptually connected to a single smart central computer such as a mainframe from the perspective of a computer scientist. System 300 is a dynamic network topology in which highly distributed parallel processes 302B, 304B, 306B, and 308B interact in parallel on computing devices 302-308.

Processes 302B-308B cooperate to represent the information sent to queues 310-314 as messages or queries to each other. The various information transmitted via the communication means includes the process of describing the data and describing the data in a manner that facilitates the order of execution, the timing of the data, the quality of service, and the interpretation or operation of the data ( There is a delivery of configuration schemes formed from customizable tag based languages between 302B-308B). One suitable customizable tag-based language is Extensible Markup Language (XML), but the invention is not limited to this language. Other customizable tag based languages can be used.

Cooperative communication between processes 302B-308B is provided by programming language 400 (FIG. 4) formed in accordance with the present invention. Language 400 is a high-order variant of the π-operation structure. In other words, language 400 is a process based language. More specifically, in addition to the other features described below, the language 400 has the ability to detect "liveness" programmatically. Liveness is an indicator that a process is in an active state. In order for a program to be trusted to do what the program is designed to do, this property needs to be verified programmatically. Programs such as web service 302A written in language 400 may be programmatically verified for "liveness." Other features include the ability to analyze the security of processes 302B-308B and resource access runtime errors. Security concerns include protecting computing devices 302-308 and its data from harm or loss. In particular, one main focus of security for non-centralized networks, such as system 300, accessed by many people through multiple queues 310, 312, 314, 316 is the prevention of access by unauthorized individuals. Web services 302A written in language 400 may be verified to detect security problems caused by untrusted web programs or untrusted computing devices.

The formal mathematical definition of language 400 is given in the appendix. Language 400 includes grammar, structural equivalent rules, and rules of operational semantics. The grammar of language 400 is a system of rules that defines how syntactic elements of queries and processes are synthesized to form acceptable programming statements. In other words, when it is not possible to accurately express in the grammar of the language 400, it is not possible to convey the concept of calling an API from one process to another. When expressions are formed correctly, semantic rules link expressions to meanings. Since the process is dynamic, the language 400 uses operational semantics to combine meaning with the process. In other words, processes evolve by working with or interacting with other processes. Understanding the meaning of expressions in language 400 is directly related to understanding its operation. By the rules of structural equivalence, the operational semantics of language 400 can be simplified in that an expression can be compared to other expressions. Thus, the number of rules of operational semantics can be kept small because these rules can be applied to a permutation of expressions.

Language 400 is a queue syntax 402 that represents several major syntax categories: a queue, a database, a communication channel, or any structured repository, which allows processes that run at different times or concurrently to communicate via messages. Query syntax (404) for expressing instructions written in a data processing language to assemble and disassemble messages, to process the structured storage represented by queue syntax 402, and to detect message patterns. ), And process syntax 406 that represents the dynamic aspects of the computing entity that can exchange processes such as messages, as well as names such as APIs, through the structured repository represented by queue syntax 402. The queue syntax 402, query syntax 404, and process syntax 406 together form the main syntactic element of the language 400. Syntactic elements 402-406 of language 400 may be used alone or combined in a permutation form to express cooperative nuances between processes, such as processes 302B-308B. Syntactic rules (described in detail with reference to FIGS. 11C-11F and section 1.1 of the appendix), structural equivalent rules (described in more detail below with reference to section 2.1 of FIGS. 11J and appendix), and operational semantic rules ( 11O-11R and described in more detail below with reference to section 3.1 of the appendix) are located in query virtual machines 302C3 and 304C3 in conjunction with queries. Syntactic rules (described in detail with reference to FIGS. 11G-11I and section 1.2 of the appendix), structural equivalent rules (described in more detail below with reference to FIGS. 11K-11N and section 2.2 of the appendix), and operational Semantic rules (described in more detail below with reference to sections 3.2 of FIGS. 11S-11V and the appendix) are located in process virtual machines 302C1 and 304C1 in conjunction with processes. Responsive virtual machines 302C2 and 304C2 include operational semantic rules that define how queues, queries, and processes respond to each other.

The programming language 400 allows expressions to be formed to describe processes such as processes 302B-308B that run in parallel and interact via communication means such as queues 310-314. Mathematically, where T and P are processes, the expression T | P describes that processes T and P are running in parallel and are probably communicating with each other or the outside world via communication means.

Queues 310-314 are represented by names (corresponding to "X", "Y", "Z" and "W" correspondingly). Programming language 400 enables the delivery of certain classes of processes, among others, processes 318-324, among others, to be represented as messages on queues 310-314. Processes 318-324 implement a configuration scheme formed from a customizable tag-based language that contains data and describes the data in a manner that facilitates interpretation of the data or performance of operations on the data. One example configuration is a query. Another exemplary configuration is a message. Another example construct is an XML document.

The query includes data and information for processing the data. Consider this example. Computing device 302 represents a computer at a publisher and computing device 304 represents a computer at a bookstore. Both publishers and bookstores have the independent ability to define their own tags in XML for information about the author, title, and publication date of a book. This book information may consist of XML documents with appropriate tags. This information is exchanged by the computing device 302 at the publisher or the computing device 304 at the bookstore, and these computing devices convert the XML document into a process 302B and a process 304B by the process kernel 302C-30C. ) Into a query expressed as a process, such as a process 318 that is passed through the queue 310.

Previous π-operational structure modifications do not allow structured information, such as XML documents, to be conveyed via communication means, such as queue 310. However, the actual execution of the application sometimes requires some exchange of structured information. Where appropriate, there is structured information that expresses the calling order of the API. Another suitable case is the above example between a publisher and a bookstore. Programming language 400 allows multidimensional data (data structures) to be implemented in processes such as processes 318-324, that is, as messages passed between processes 302B-308B. The language 400 is represented in a customizable tag-based language that includes data and describes the data in a manner that facilitates the interpretation of the data or the operation of the data between the processes via a queue in a parallel distributed decentralized network. Allows the creation of an environment to facilitate the exchange of configuration methods.

5 is a visual representation of syntax expressions relating queue 310 (X), queries 504, 506 (Q ₀ , Q ₁ ), and processes 302B, 304B (T, P). One or more queries 502 are stored in queues 310-316, which are processes that implement structured data or names that do not have an explicit structure. In order to pass a structured data file, such as XML document 500A, through queue 310 to process 304B, process 302B converts XML document 500A into query 500B. Next, the query 500B is written to the queue 310. Query 500B is treated as a process by process kernels 302C-308C. Unlike previous variations of the π-operation structure, programming language 400 allows a process such as query 500B to pass through a communication means such as queue 310. Query 500B includes more than pure names in that query 500B also includes the structured content of XML document 500A. To obtain query 500B, process 304B reads queue 310.

Programming language 400 provides a set of query operations used to assemble and disassemble a query, process a queue, and detect patterns in the query. Another query operation is used to put a message on a queue, get a message from a queue, and create a new message from an existing message. The query consists of two parts: the head and the body. The head of the query defines a series of parameters and their corresponding types. The body is a series of bindings. The query is called by binding its parameters to the arguments and activating its set of bindings. The binding defines a relationship between two terms. Not all terms can be bound to each other. An effective binding exists when a binding binds a term of a type to a term of its complementary type. Queries can be likened to conventional procedures. The head of the query is the same as the signature of the procedure, the body of the query is the same as a series of programming statements in the procedure, and each binding uses data stored in the parameters of the procedure's signature or data in the parameters of the procedure's signature. Programming statement that places a.

Mathematically, the relationship between queue 310, query 500B and process 304B can be syntactically represented as X [Q ₀ ] .P, where X is queue 310 and Q ₀ is query ( 500B), and P is a process 304B which is a continuing point after the query Q ₀ is written to the queue X. Thus, linguistically, the mathematical expression X [Q ₀ ] .P describes the process of placing query 500B in queue 310, after which the process continues with execution of process 304B. In the framework of programming language 400, both Q ₀ and P are processes in mathematical notation X [Q ₀ ] .P. Programming language 400 identifies a subset of processes (or some class of processes) that can be delivered as messages over queue (X). This subset contains queries, each of which correlates to customizable tag-based data structures such as those contained in XML documents.

One major aspect of language 400 is a collection of equation rules for determining structural equivalence between queries and processes. The process of determining structural equivalence using these equation rules of language 400 is performed between two documents, such as two programs or two software specifications, to ensure that all relevant matters are met. You are not bound by minor differences. These structural equivalence rules allow the operational semantics of language 400 to be simplified as described above.

6A is a program 602 written in a language suitable for this description. Program 602 includes a main () function that is the starting point of execution of any language, such as C or C ++. Between the first set of brackets is an if statement containing the test condition (A == 7). The test condition determines whether variable A is equal to the value 7. If the test condition is true, a programming statement included in the second set of brackets is executed. The first programming statement calls the fork () function which takes the variable P0 as an argument. In some languages, the fork () function starts a child process in a parallel system after the parent process has started. In this case, the child process is represented by the argument P0. As such, after the fork () function is called, the child process P0 is executed in parallel with the parent process executing the program 602. The second programming statement also includes a call to the fork () function, but takes no variable P0 as an argument, and the second call of the fork () function takes a variable P1 as an argument. Another child process represented by the argument P1 is started by a call to the second fork () function. The child processes P0, P1 execute in parallel with each other at the exit of the program flow from the closing bracket of the second set of brackets.

Another program 604 is similar to program 602 in many respects, but there are some differences. One difference is the test condition of the IF statement of the program 604, which includes the variable B instead of the variable A. Another difference is that child process P1 is started with the first call of the fork () function before calling child process P0. Despite these differences, the logical flow of both programs 602 and 604 ultimately reaches the fork () statement of both programs 602 and 604 if the test condition of both IF statements is true. Thus differences in the names of variables A and B can be ignored and do not affect the logical structure of programs 602 and 604. In addition, since the child processes P0 and P1 are executed in parallel, the order of their invocations can also be ignored.

As noted above, program 602 can be written by many different programming languages, including various different grammatical structures that interfere with structural equivalence analysis. Using language 400, program 602 may be represented by properties separate from the grammatical details of program 602. For example, the core of the program 602 is to execute the child processes P0 and P1 in parallel. This key point can be represented by language 400 by converting program 602 to specification 602A. Parallel execution of processes P0 and P1 is represented as "P0 | P1" in program 602A. The statement "P0 | P1" is contained between the tag <I_DO> and its corresponding end tag </ I_DO>.

Suppose that process 302B needs a service in which child process P0 is desired to run in parallel with another child process P2. This requirement is captured by the statement "P0 | P2" as shown in the specification 302D written in the language 400. The statement "P0 | P2" is between the tag <I_NEED> and its corresponding end tag </ I_NEED>. Further assume that process 302B obtains specification 602A from discovery component 328 to determine whether program 602 is suitable for the task that process 302B is trying to achieve. Using structural equivalence analysis, process 302B can quickly determine that program 602A will not be able to provide the requested service as specified by specification 302D. This is because the program 602 executes the child processes P0 and P1 in parallel while the process 302B instead requires the child processes P0 and P2 to run in parallel.

One of the set of equation laws of language 400 allows for apparently distinct cues to be fused so that one queue can replace another in operation. This is called substitution equivalence in section 2.2 of the Annex. As shown in FIG. 7A, process 302B uses queue 310 (Queue X) to send and receive messages (or to record and read queries). Without using queue 310, process 304B communicates with queue 702 (Queue X ′) to send and receive messages (or to record and read queries). Suppose a query is placed on queue 702, where name X is bound to name X '(name X: =: name X'), except that operator: =: is a binding operator in language (400). ). This indicates that queue 310 is essentially fused with queue 702 so that processes 302B-304B can operate or communicate on the same queue, such as queue 310. See FIG. 7B. Using the equation law of language 400, processes 302B and 304B may discover new ways to access queues (or, among other structured repositories, in particular databases or channels).

The input / output mechanism (I / O) of the conventional variant of the π-operation structure is asymmetric. Consider the following mathematical example. , here And u say the same link, Indicates that the link is outputting something, such as X, U indicates that the link is inputting something, such as Y, X is output data, Y is input data, and P and Q are expressions. Wow It is a process that continues after it is executed. Asymmetry arises from the fact that output data X is not bound to channel U while input data Y is bound to channel U. The term "bound" means that the operating range of Y is limited to the link to which Y is bound. In other words, web service 116 ( ) Passes the API used to call the web service 108 to the web service 108, the web service 116 forgets about that API. Asymmetric I / O prevents the formation of distributed network topologies such as system 300. The present invention overcomes or reduces the above problems by providing symmetrical I / O.

8 illustrates a symmetrical I / O aspect of a system 300 formed in accordance with the present invention. Process 302B is mathematically Where T is the process 302B Refers to the cue 310 while outputting something, Refers to the cue 312 while outputting something, Assume that queue refers to queue 316 while outputting something, and S refers to process 306B. Process 304B is also mathematically as follows, i.e. Where P is the process 304B, X refers to the queue 310 while typing something, Y refers to the queue 312 while typing something, and Z inputs something. Suppose that queue 314 is while R is referring to process 308B. Process T runs in parallel with process P, i.e. mathematically Assume that is In execution, the process Is distributed to queue 310 (X), and the process It is also distributed to queue 310. These two processes And After reacting in queue 310, the process Is distributed to queue 312 (Y). At this time, in queue 312, a query is issued that binds queue 316 to queue 314 in parallel with a running process, that is, mathematically Assume that is Upon issuing such a query, queue 316 (W) is fused with queue 314 (Z). Any input or output at W is passed to Z, so any input or output at Z is passed to W, thus forming a distributed network topology. From channel 312, another subprocess Is distributed to queue 316 (W), and another subprocess It is distributed to this queue 314 (Z). From queue 316, process 306B (process S) is distributed and executed as a continuous point. From queue 314, process 308B (process R) is also distributed and executed as another continuation point.

Language 400 has, in addition to its syntax, a set of rules for describing the evolution of a process. In other words, these rules define the operational semantics of language 400. The operational semantics of language 400 describe the relationship between syntax elements 402-406 and their intended meanings. Thus, a program statement written in language 400 may be syntactically correct but semantically incorrect. In other words, statements written in language 400 may be in a reasonable form but still convey a false meaning. One example of the operational semantics of language 400 is the communication reduction rule (implemented in reactive virtual machines 302C2 and 304C2) shown schematically in FIGS. 9A and 9B. Query 902A (Q ₀ ) is ready to be sent to database 904 (V) by process 302B (T).

For convenience of explanation, the query 902A is shown in a database form. This form includes data as well as “holes” that may be filled when the data is calculated by the database 904. For example, a query can be likened to a question with information about the question to be answered. Thus, the information is the data in the form and the answer is the data that will fill the holes in the form. As another example, a form can be likened to a linear simultaneous equation that can be algebraically solved if sufficient information is available. After the transfer of query 902A to database 904, the process continues execution of process 306B (S). Mathematically, the process of sending form 902A to database 904 and continuing process 306B can be described as follows. , Where V represents database 904, Q ₀ represents form 902A, and S represents process 306B.

Assume that the process sends form 902C to database 904 and then continues process 308B without transferring form 902A to database 904 and continuing with process 306B. Mathematically, this can be described as follows. , Where V represents database 904, Q ₁ represents form 902C, and T represents process 308B.

process Running and the process In the presence of this choice between executing, this choice may be abbreviated to form 906A (Q), which is sent to database 904, after which both processes 306B and 308B are executed in parallel. See FIG. 9B. Mathematically, this result is It is expressed as Formation of form 906A occurs by joining forms 902A and 904A such that query 906A becomes standard (described below). On the other hand, the formation of the query 906A from two different separate forms 902A, 902C results in two alternatives ( or One form 906A may be sent to database 904 and both processes 306B and 308B may be active and run in parallel before only one selection may be made between the two. One way to understand this is to liken form 902A to a first linear simultaneous equation with three terms and form 902C to a second linear simultaneous equation with three terms. From linear algebra, there are no solutions to the two linear simultaneous equations, but given additional data (another linear simultaneous equation), two linear simultaneous equations can be calculated in form so that all the solutions can be found. Can be concluded. Form 906A illustrates the calculation of two forms 902A, 902C, where no further calculation can be performed when there is no more data.

10A-10C diagrammatically illustrate another operational semantic rule, a lift rule (described in more detail with reference to FIG. 11U and section 3.2 of the appendix) for the evolution of the process. As shown in FIG. 10A, process 302B individually communicates with databases 1006 and 904 to send and receive messages (or queries). Database 1006 is named "U" and database 904 is named "V". Assume that process 306B sends query 1002A to database 904 that includes a binding that represents the relationship between name "U" and name "V". By sending query 1002A, process 302B finds that the names "U" and "V" refer to the same database. In other words, a message placed in database 1006 by process 302B is forwarded to database 904, and a message placed in database 904 by process 302B is correspondingly forwarded to database 1006. do. Process 302B can either interpret from query 1002A to refer to a database with the same name "U", "V", or to have two separate databases forwarding messages sent by process 302B to each other. There are certain conditions (described in detail below with reference to FIG. 11U) that must be met before they are present.

10C is shown a system 1010 showing a number of computing devices distributed across multiple regions. Process 302B runs on computing device 302 in San Francisco area 1012. Process 304B runs on computing device 304 in Seattle area 1016, and process 308B runs on computing device 308 in Portland area 1014. Process 302B was assisted by process 304B to perform some task. Without noticing process 302B, process 304B may not be able to accomplish all of the tasks specified by process 302B. Thus, process 304B was assisted by process 308B to perform a task that is not within the scope of process 304B. By issuing a query, such as query 1002A, to database 1006, a message coming from process 302B, such as message 1020, to database 1006, automatically causes process 308B to perform the requested task. Forwarded to database 904. In another alternative, process 302B may communicate with database 904 directly to exchange messages. However, process 302B need not do so and can continue to communicate with database 1006.

11A-11V illustrate a method 1100 for compiling or executing a program, such as a web service 302A (hereinafter referred to as "program 302A"), by a process kernel, such as process kernel 302C. Program 302A is written in language 400. In analyzing the program, the method 1100 executes a set of syntactic rules that govern the structure and content of query expressions and process expressions. A set of equation laws that govern the structural equivalence of query expressions and process expressions is also executed by the kernel process 302C. The language 400 also includes a set of operational semantic rules that govern the meaning of the query expressions and process expressions that are correctly formed according to the set of syntactic rules of the language 400. These series of operational semantic rules are executed by process kernel 302C. For simplicity, the following description of method 1100 refers to various components shown in connection with the system 300 shown in FIGS. 3A-3C.

From the start block, the method 1100 proceeds to a series of method steps 1102 defined between a continuation terminal ("terminal A") and an exit terminal ("terminal B"). A series of method steps 1102 executes the program against syntactic rules that govern the structure and content of query statements formed from queue syntax 402. From terminal A (FIG. 11C), the method 1100 proceeds to block 1114 where the process kernel 302C obtains the query expression Q from the program 302A. Next, in decision block 1116, the process kernel 302C determines that the query (Q) expression is in syntactical form. Determine whether or not

Each query written in language 400 is in the form of a syntax. Has a syntax element Represents the head of the query and the syntax element Represents the body of the query. Each query written in language 400 has a head and a body. The head declares the number of parameters and their respective types. The body contains a series of bindings. A named sequence of statements (unnamed queries), with associated constants, data types, and variables, in which a query typically performs a task, can be expressed using the language 400. Queries can be likened to conventional programming procedures. For example, the head of a query is similar to the signature of a procedure, while the body of the query is similar to a series of statements contained within a procedure. The head delimiter <> contains the symbol T *, which represents zero or more query terms (defined below). Within the body delimiter () is a symbol C * representing zero or more constraints (described below).

If the answer to the test at decision block 1116 is no, meaning that the query Q is not written in syntax form recognized by the language 400, the method 1100 completes execution and ends. . If the answer is yes, the method 1100 proceeds to another decision block 1118 where the process kernel 302C determines whether each constraint C in the body of the query has the syntax form T: =: T. Wherein T is a query term as described above and further described below, and the symbol: =: indicates a binding that defines a relationship between two query terms. If the answer is no, meaning that one constraint of the body of the query was not written in a form that is appropriate for language 400, the method 1100 completes execution and ends. Otherwise, the answer at decision block 1118 is yes, and the method proceeds to another decision block 1120.

At decision block 1120, process kernel 302C determines whether the query term T is a literal (hereinafter referred to as "TOP"). A literal is a value used in a program that is expressed as it is not as a result of a variable or expression. Examples of literals are the numbers 25 and 32.1, the letter a, the string Hello, and the boolean TRUE. If the answer to decision block 1120 is yes, the method 1100 proceeds to another continuing terminal ("terminal A5"). From terminal A5, the method 1100 proceeds to decision block 1146 and the process kernel 302C determines whether there is another query expression to analyze. If the answer is no, the method 1100 proceeds to another continuing terminal ("Terminal B"). If not, the answer at decision block 1146 is yes, and the method 1100 loops back to block 1114 to obtain another query expression from the program 302A for analysis.

In decision block 1120, if the answer is no, the method 1100 proceeds to another decision block 1122, where the process kernel 302C determines that the query term T is complementary literal (hereinafter From, it is called "BOTTOM". Complementary literals are inversions of literals. If the answer at decision block 1122 is yes, the method 1100 proceeds to terminal A5 (described above). If instead the answer at decision block 1122 is no, the method 1100 proceeds to another decision block 1124. Here, process kernel 302C determines whether query term T is a discarder (separated by symbol "_"). The discarder is a query that has only input parameters and no output parameters. If the answer to decision block 1124 is yes, the method 1100 proceeds to terminal A5 described above. At decision block 1124, if the answer is no, the method 1100 proceeds to another continuing terminal ("terminal A1").

From terminal A1 (FIG. 11D), if the answer is no, the method 1100 proceeds to decision block 1126 where the process kernel 302C indicates that the query term T is a name (or a literal string such as “hello”). Verify that it is. Preferably, alphabetic characters are syntactically treated by language 400 as a variable that is a named storage location that can contain data that can be modified during program execution. If a letter is preceded by an alphabetic character in the language 400, the alphabetic character is treated by the language 400 as a literal string rather than a variable. If the answer to decision block 1126 is yes, the method 1100 proceeds to terminal A5 (described above). At decision block 1126, if the answer is no, the method 1100 proceeds to another decision block 1128 where the process kernel 302C determines whether the query term T is a variable (such as X). Decide If the answer is yes, the method 1100 proceeds to terminal A5 (described above).

In decision block 1128, if the answer is no, the method proceeds to decision block 1159 and the process kernel 302C determines that the query term T is of the form ". Determines whether it is a local variable with ". Contains the term X, which represents a variable in a program written in language 400. Caret, which is a small upward symbol (^) on the sixth key of the top row of the microcomputer keyboard, usually contains a variable X (In the context of computer science, a local variable means a variable that is limited to a given block of code, usually a subroutine, but in the present invention the scope of the local variable is limited to processes). Indicates the creation of a local variable, X, that can be used to export information that will continue to be used in the process. If the answer is yes in decision block 1159, the method 1100 proceeds to terminal A5 (described above).

In decision block 1159, if the answer is no, the method proceeds to decision block 1157 and the process kernel 302C determines that the query term T is of the form ". Determines whether it is a local variable with ". Contains the term X representing the variable, the term ^ is a caret, and the term Represents a local variable X in which a process can import information (to be used) from the evolving computing environment. If the answer is yes in decision block 1157, the method 1100 proceeds to terminal A5 (described above). If not, the decision is no and the method 1100 proceeds to another continuing terminal ("terminal A2").

From terminal A2, the method flow proceeds to decision block 1130 where the process kernel 302C checks the query term T to see if the query term T is inverse (separated by ~ symbols). If the decision is yes, the method flow proceeds to terminal A5 (described above). Otherwise, the decision is no and the method 1100 enters a decision block 1132. At decision block 1132, process kernel 302C determines whether query term T is a tuple that is an ordered set of elements. Language 400 has two symbols for representing tuples, syntactic symbols " And the syntactic symbol "#". If the answer at decision block 1132 is yes, the method flow proceeds to terminal A5 (described above); otherwise, if the decision is no, then the method. 1100 proceeds to decision block 1134. Here, process kernel 302C has a query term T form. A check is made to see if X is found, where X * represents one or more variables and Q represents a query. Thus, the process expression Represents two or more variables in the body of the query, separated by commas and zero or more variables in the head of the query. If the decision is yes at decision block 1134, the method flow proceeds to terminal A5 (described above). If the decision is no, the method 1100 proceeds to decision block 1136. Here, the process kernel 302C checks whether the query term T is a left injection INR (X). Conventionally, the left injection operator "inl ()" is used to indicate the source of an element in the union of two sets. For example, assume that set A is summed with set B (denoted A + B). Each element of the set A + B is actually tagged with the label inl to indicate that the element is from the set A (because the alphabet letter A is left of the set A + B visually). In the present invention, the constructor inl is preferably a query expression It is used to represent the operation (described below) for the left Q of the body of. If the answer to decision block 1136 is yes, the method flow proceeds to terminal A5 (described above). Otherwise, the method 1100 enters another continuation terminal ("terminal A3").

From terminal A3, the method 1100 proceeds to decision block 1138 and the process kernel 302C determines whether the query term T is a right injection INR (X). As outlined above, the form In the presence of a query of, the left injection constructor (INL (X)) can cause the variable X to be bound to the constraint Q _L , and the right injection constructor (INR (X)) can cause the variable X to be bound to the constraint Q _R. Can be. If the answer to decision block 1138 is yes, the method 1100 proceeds to terminal A5 (described above). Otherwise, the method flow proceeds to decision block 1140 where the process kernel 302C assumes that the query term T is of the form. Determine whether or not If the answer to decision block 1140 is yes, the method 1100 proceeds to terminal A5. Otherwise, the method flow enters another decision block 1142. Here, process kernel 302C determines whether query term T has type? T. See decision block 1142. Operator "?" Query term T It can be thought of as a read operator that binds to the first term in the query Q contained in the body of. If the answer to decision block 1142 is yes, the method flow proceeds to terminal A5 (described above). If the answer is no, the method determines whether the query term is a copy operation (eg, "T @ T"). If the answer at decision block 1144 is yes, the method 1100 enters terminal A5 (described above). If instead the answer is no, meaning that the query Q was not written in syntax form recognizable by the language 400, the method 1100 completes execution and ends.

From terminal B (FIG. 11A), the method 1100 continues with a series of processing steps 1104 defined between terminal ("terminal C") and terminating terminal ("terminal D"). This series of processing steps 1104 executes the program 302A against syntactic rules that govern the structure and content of the process statement. From terminal C (FIG. 11G), process kernel 302C receives process expression (from program 302A). ). See block 1148. Next, at decision block 150, the process kernel 302C is assigned a process expression. It is determined whether this is "0" indicating the process stop or inactivity of the process. If the answer is yes, the method flow proceeds to another continuing terminal ("terminal C3"). Otherwise, the method flow proceeds to another decision block 1152. Process Kernel 302C is a process expression This form Wherein X is a variable representing a channel, queue, database, or other structured repository, Q represents the query described above and illustrated in FIGS. 11C-11F, Indicates that query Q is sent to X or placed in X, and the period "." Represents a sequence from one process P to another Represents a sequence from a portion of to another portion P of the same process. If the answer at decision block 1152 is yes, the method 1100 proceeds to terminal C3. Otherwise, if the answer is no, the method 1100 proceeds to decision block 1154. Process Kernel 302C is a process expression this Numerous Determine whether the sum of Sum is a process expression Indicates that the process represented by can implement one of many alternatives. E.g, As the sum of The process represented by or You can run If the answer to decision block 1154 is yes, the method 1100 proceeds to terminal C3. Otherwise, if the answer is no, the method flow proceeds to another continuing terminal ("terminal C1").

From terminal C1 (FIG. 11H), the method 1100 proceeds to decision block 1156 so that the process kernel 302C is a process expression. This form Where NEW represents an operator in the language 400 for generating a new name that is bound to a process, and (NEW X) represents the creation of a new name X in a process, NEW X) P indicates that a new variable X is created and bound to process P. If the determination at decision block 1156 is YES, the method 1100 continues to terminal C3. If the answer is no, the method 1100 enters a decision block 1158. Here, process kernel 302C is a process expression Determine whether or not this form P | P, where P | P indicates that one process runs in parallel with another process. If the answer is yes in decision block 1158, the method flow proceeds to terminal C3. Otherwise, the method 1100 proceeds to decision block 160. Process kernel 302C may process the expression at decision block 1160. Determine whether or not this form! P, where the exclamation point "!" Represents the replication operator and! P represents infinite composition P | P | ... The replication operator! Allows developers to express the infinite behavior of a process using language 400. If the decision is yes at decision block 1160, the method 1100 proceeds to terminal C3. Otherwise, the method 1100 enters another continuation terminal ("terminal C2").

From terminal C2 (FIG. 11I), the method 1100 proceeds to decision block 1162 so that the process kernel 302C is a process expression. Determine whether or not this form X [P]. Syntactic form X [P] indicates that a developer using language 400 can place or transfer process P to X, where X is different as described above. Among the structured repositories include channels, queues, and databases in particular. If the answer to decision block 1162 is yes, the method 1100 proceeds to terminal C3. Otherwise, the answer is no, and the method flow proceeds to decision block 1164. Process Kernel 302C is a process expression It is determined whether or not this form has a form <Q> which is a lifted query (described in more detail below). If the decision is yes at decision block 1164, the method 1100 enters terminal C3. Otherwise, the answer is no, and the method 1100 completes execution and ends. The reason for ending method 1100 at this point is that the process expression This is because the language 400 is formed in a way that does not conform to grammar.

From terminal C3 (FIG. 11I), the method 1100 proceeds to decision block 1166 and the process kernel 302C determines whether the program 302A contains other process expressions to check. If the answer is no, the method flow proceeds to another continuing terminal ("Terminal D"). Otherwise, the answer is yes, and the method 1100 proceeds to another continuation terminal ("terminal C4"), which C4 loops back to block 1148 so that the method steps described above are repeated.

From terminal D (FIG. 11A), the method 1100 proceeds to a group of processing steps 1106 where the method executes the program using a set of equation laws that govern the structural equivalence of the query expression (see FIG. 11J). Processing step 1106 continues between the terminal ("terminal E") and the terminating terminal ("terminal F").

From terminal E (FIG. 11J), the method 1100 proceeds to block 1168, where the process kernel 302C obtains two or more query expressions for structural equivalence comparison. The method then determines whether the query context K has the form K [T: =: U]. Query context K represents a number of queries with holes that can be configured to be filled by one or more constraints. If the answer to decision block 1178 is yes, then query context K is structurally equivalent to another query context K [U: =: T]. See block 1170B. The method flow then proceeds to another continuing terminal ("terminal E1"). Otherwise, if the decision at decision block 1170A is no, the method 1100 enters another decision block 1172A. Here, process kernel 302C determines whether query context K has the form K [T ₀ : =: U ₀ , T ₁ : =: U ₁ ]. If the answer in decision block 1172A is yes, then query context K is structurally equivalent to another query context K [T ₁ : =: U ₁ , T ₀ : =: U ₀ ]. See block 1172B. The method flow then proceeds to terminal E1. Instead, if the answer is no in decision block 1172A, the method 1100 proceeds to terminal E1 and terminal E1 proceeds to another decision block 1174. Process kernel 302C determines whether there are more query expressions in the program to analyze for structural equivalence. See block 1174. If the answer is no, the method 1100 proceeds to end terminal F. If not, the answer is yes, and the method 1100 proceeds to block 1168 where the method steps described above are repeated.

From terminal F (FIG. 11A), the method 1100 proceeds to another continuing terminal ("terminal G"). From terminal G (FIG. 11B), the method 1100 continues with a series of processing steps 1108 defined between the terminal ("terminal H") and the terminating terminal ("terminal I"). During these processing steps 1108, the method executes the program using a set of equation laws that govern the structural equivalence of the processed statement.

From terminal H (FIG. 11K), the method 1100 proceeds to block 1176, where the process kernel 302C receives several process expressions from the program 302A for structural equivalence analysis. 1 and 2) to obtain. Then, the method is a process expression Determine whether 1 has the form P ₀ | P ₁ . See decision block 1178A. If the decision is yes, the process expression 1 Process expression when 2 has the form P ₀ | P ₁ It is structurally equivalent to 2. See block 1178B. The method 1100 then proceeds to another continuing terminal ("terminal H7"). If the answer to decision block 1178A is no, the method 1100 proceeds to another decision block 1180A, so that the process kernel 302C returns a process expression. Determine whether 1 has the form P | 0. If the answer is yes in decision block 1180A, the process expression 1 is the process expression Process expression when 2 has form P It is structurally equivalent to 2. See block 1180B. The method flow then proceeds to terminal H7. If the answer to decision block 1180A is no, then the method 1100 proceeds to another decision block 1182A. Here, process kernel 302C is a process expression Determines whether 1 has the form! P. If the answer is no, the method 1100 proceeds to another continuing terminal ("terminal H2"). If the answer is yes in decision block 1182A, the method 1100 proceeds to another continuing terminal ("terminal H1").

From terminal H1 (FIG. 11L), the method 1100 proceeds to block 1182B, where the process expression 1 is the process expression Process expression if 2 has the form P |! P It is determined to be structurally equivalent to 2. The method 1100 then proceeds to terminal H7.

From terminal H2 (FIG. 11L), method 1100 proceeds to decision block 1184A, where process kernel 302C is a process expression. Determines whether 1 has the form P ₀ + P ₁ . If the answer to decision block 1184A is YES, then the process kernel 302C returns a process expression. Process expression when 2 has the form P ₁ + P ₀ 1 process expression We decide to be structurally equivalent to 2. See block 1184B. The method flow then proceeds to terminal H7. If instead the answer at decision block 1184A is no, the method 1100 proceeds to another decision block 1186A. Here, process kernel 302C is a process expression Determines whether 1 has the form P ₀ +0. If the answer is yes, the method 1100 proceeds to block 1186B, where the process kernel 302C selects a process expression. Process expression when 2 has form P 1 process expression Determined to be structurally equivalent to 2. The method 1100 then proceeds to terminal H7. If the answer is no, the method flow proceeds to another decision block 1188A. Here, process kernel 302C is a process expression Determines whether 1 has type (NEW X) (NEW Y) P. If the answer is yes, the method 1100 proceeds to another continuing terminal ("terminal H3"). Otherwise, if the answer is no, the method 1100 proceeds to another continuing terminal ("terminal H4").

From terminal H3 (FIG. 11M), the method 1100 proceeds to block 1188B, where the process expression 1 is the process expression Process expression when bivalent has the form (NEW Y) (NEW X) P It is determined to be structurally equivalent to 2. From terminal H4 (FIG. 11M), method 1100 proceeds to another block 1190A, where process kernel 302C is a process expression. Determines whether 1 has type (NEW X) (NEW X) P. If the answer to decision block 1190A is yes, then the process expression 1 is the process expression Process expression when bi has form (NEW X) P It is structurally equivalent to 2. See block 1190B. The method 1100 then proceeds to terminal H7. If the answer to decision block 1190A is no, the method 1100 proceeds to another decision block 1192A. Here, process kernel 302C is a process expression Determines whether 1 has the form (NEW X) P | Q. If the answer at decision block 1192A is no, the process proceeds to block 1192B, where the process kernel 302C expresses a process expression. Process expression when bivalent form (NEW X) (P | Q) 1 process expression Determined to be structurally equivalent to 2. Name X is preferably a free name in process Q. In other words, the name X is not bound to process Q. The method 1100 then proceeds to terminal H7.

If the answer to decision block 1192A is no, the method 1100 enters decision block 1194A. Here, process kernel 302C is a process expression 1 this form Determines whether or not, where <> represents the head of a query that contains nothing, Represents a set of constraints or a set of bindings, Indicates that literal X is bound to literal X 'or that literal X has an equivalent relationship to literal X', Query Indicates that the head of is a query running in parallel with process P. If the answer to the test at decision block 1194A is no, then the method 1100 proceeds to terminal H7. Instead, if the answer in decision block 1194A is YES, the method 1100 proceeds to another continuing terminal ("terminal H6").

From terminal H5 (FIG. 11N), method 1100 proceeds to another decision block 1194B. At decision block 1194B, process kernel 302C queries Determines whether is canonical. The query is said to be standard or instead standard only if all of its constraints (binding in the body of the query) are irreducible and the query is not a failure. Constraints are non-abbreviated in a query only if a second query exists such that the query is mapped or shortened to the second query, and the constraint is an element of the second query. A query is said to fail only if the query is mapped or abbreviated to another query and that other query contains a failure. Type L _0: =: (Im-stage, L _0, L ₁ is a literal), the constraints of L ₁ is the failure in the case where L ₀ non-conservative equivalent of L _1.

If the answer to decision block 1194B is yes, the method 1100 proceeds to block 1194C. Here, process kernel 302C is a process expression Bivalent form Expressions if you have 1 process expression Determined to be structurally equivalent to 2. Process expression Indicates that whenever a name X occurs in process P, this occurrence can be replaced by the name X '. In this regard, it should be recalled that processing steps 1194A-1194C describe a substitution equivalent (described above in connection with FIGS. 7A and 7B). The method 1100 then proceeds to terminal H7.

If the answer at decision block 1194B is no, the method 1100 proceeds to terminal H7. From terminal H7, the method 1100 proceeds to another decision block 1196, where the process kernel 302C checks to see if there are more process expressions for structural equivalence analysis. If the answer to decision block 1196 is no, then the method flow proceeds to end terminal I. Otherwise, the method 1100 continues to the terminal ("terminal H8"). From terminal H8 (FIG. 11K), method 1100 loops back to block 1176, and the method steps described above are repeated.

From terminating terminal I (FIG. 11B), the method 1100 proceeds to a series of processing steps 1110, where the method proceeds to the program 302A for operational semantic rules that govern the meaning of the query statement within the program 302A. Run A series of processing steps 1110 continue to be defined between the terminal ("terminal J") and the terminating terminal ("terminal K"). In language 400, operational semantic rules are basically a series of evolving process relationships. Processes are dynamic in nature and therefore the process continues to change or evolve from one point to another. The operational semantic rules of language 400 provide a carefully guided evolution of the process represented by language 400. The syntactic rules described above in FIGS. 11C-11I allow a developer to express the nuances that process evolves through the operational semantics of language 400.

From terminal J (FIG. 11O), the method 1100 proceeds to block 1 198, where the process kernel 302C obtains the binding from the query expression in the program. Next, at decision block 1199A, process kernel 302C determines whether binding B includes binding TOP: =: BOTTOM. If the answer is yes, then process kernel 302C shortens binding B to nothing. See block 1199B. The method flow then continues to the terminal ("terminal J4"). Instead, if the answer is no, the method flow proceeds to decision block 1197A, where the process kernel 302C determines whether binding B includes bindings X: =: T, U: =: X. Decide If the answer is yes, then process kernel 302C shortens binding B to binding T: =: U. See block 1197B. The method flow then proceeds to terminal J4. If the answer is no, the method 1100 proceeds to another continuing terminal ("terminal J1").

From terminal J1 (FIG. 11P), the method 1100 proceeds to another decision block 1 193A, where the process kernel 302C is bound to B. Determine whether to include. If the answer is yes, then process kernel 302C binds B. Abbreviate See block 1193B. The method flow then proceeds to terminal J4. If the answer to decision block 1193A is no, then the method 1100 proceeds to another decision block 1191A. Process Kernel 302C is bound by B binding Determine whether to include. If the answer in decision block 1191A is yes, then the process kernel 302C will bind binding B. Abbreviate See block 1191B. The method 1100 then proceeds to terminal J4. If the answer to decision block 1191A is no, the method 1100 proceeds to another decision block 1149A.

If the answer to decision block 1191A is no, the method 1100 proceeds to another decision block 1149A. Process kernel 302C is bound to Determine whether to include. If the answer to decision block 1189A is YES, the method 1100 proceeds to block 1189B, where the process kernel 302C removes binding B. Abbreviate The method flow then proceeds to terminal J4. If the answer to decision block 1189A is no, the method 1100 proceeds to another continuing terminal ("terminal J2").

From terminal J2, the method 1100 proceeds to another decision block 1187A. Here, process kernel 302C has binding B Determine whether it contains. If the answer is yes, then process kernel 302C binds B. Abbreviate See block 1187B. The method 1100 then proceeds to terminal J4. If the answer to decision block 1187A is no, the method 1100 proceeds to another decision block 1185A. Process kernel 302C is bound to Determine whether to include. If the answer in decision block 1185A is YES, then the process kernel 302C attaches binding B. Abbreviate See block 1185B. The method 1100 then proceeds to terminal J4. If the answer to decision block 1185A is no, the method 1100 proceeds to another decision block 1183A. Process kernel 302C is bound to Determine whether to include. In other words, a query Is bound to the divider operator. If the answer in decision block 1183A is yes, then process kernel 302C binds binding B as follows: Abbreviate In other words, a query Each term in list X in the head of is bound to the divider operator. The method 1100 then proceeds to terminal J4. If the answer at decision block 1183A is no, the method flow enters another continuing terminal ("terminal J3").

From terminal J3 (FIG. 11R), the method 1100 proceeds to another decision block 1181A, where the process kernel 302C is bound B in form. Determine whether or not In other words, process kernel 302C lists binding B in the head. Have another It is determined whether or not in the form of a query having three constraint lists in the body including a. If the answer in decision block 1181A is yes, then the process kernel 302C is also listed. end Determine whether it can be abbreviated as See decision block 1181B. If the answer to decision block 1181B is yes, then binding B queries Is abbreviated as See block 1181C. The method flow proceeds to terminal J4.

If the answer at decision blocks 1181A, 1181B is no, the method 1100 proceeds to another decision block 1179A. Process kernel 302C queries that binding B is below Determine whether to include. If the answer in decision block 1179A is yes, then binding B queries Is abbreviated as See block 1179B. In other words, a list with name X if name U is bound to name X in the body of the query. Everywhere in the name X can be replaced by the name U. The method flow then proceeds to terminal J4. Otherwise, the answer at decision block 1179A is no, the method flow proceeds to terminal J4, and terminal J4 proceeds to another decision block 1177. Here, process kernel 302C determines whether there is another query expression to apply the semantic rules of language 400. If the answer is no, the method 1100 proceeds to end terminal K. If the answer to decision block 1177 is yes, the method 1100 proceeds to another continuing terminal ("terminal J5"). From terminal J5, the method 1100 loops back to block 1 198 and the method steps described above are repeated.

From terminating terminal K (FIG. 11B), the method 1100 proceeds to a series of processing steps 1112, where the method executes the program 302A against operational semantic rules that govern the meaning of the process expression. A series of processing steps 1112 are defined between the terminal ("terminal L") and the terminating terminal ("terminal M").

From terminal L (FIG. 11S), the method 1100 proceeds to block 1175, where the process kernel 302C writes the process expression in the program 302A. ). Next, at decision block 1173A, process kernel 302C is a process expression. Sum this Determine whether to include. If the answer to decision block 1173A is yes, the method 1100 proceeds to another decision block 1173B. Here, the process kernel 302C is in a form that can be abbreviated to another query Q in standard form. Determines whether there is a binding of. Both define permutations that map or abbreviate terms (see definition 3.2.1 in section 3.2 of the appendix). Both are preferably interpreted as database joins. If the answer in decision block 1173B is YES, then the process kernel 302C may process the process expression. Is a process indicating that the abbreviated query Q is sent to structured repository X, and then both processes P ₀ and P ₁ run in parallel Abbreviate See block 1173C. Processing steps 1173A-1173C have been described above in connection with FIGS. 9A and 9B. Then, from block 1173C, the method 1100 proceeds to another continuation terminal ("terminal L6").

If the answer at decision blocks 1173A and 1173B is no, the method 1100 proceeds to another decision block 1171A. Process Kernel 302C is a process expression this Determine whether to include. If the answer is yes, the method 1100 proceeds to another decision block 1171B, where the process kernel 302C determines whether process P can be abbreviated to process P '. If the answer to decision block 1171B is yes, the method 1100 proceeds to another continuing terminal ("terminal L1"). If the answer at decision blocks 1171A, 1171B is no, the method 1100 proceeds to another continuing terminal ("terminal L2").

From terminal L1 (FIG. 11T), the method 1100 proceeds to block 1171C, where the process kernel 302C is a process expression. of Abbreviate The method flow then proceeds to terminal L6. From terminal L2 (FIG. 11T), the method 1100 proceeds to another decision block 1 169A, whereby the process kernel 302C expresses a process expression. Determines whether this contains (NEW X) P. If the answer is yes, the method flow proceeds to decision block 1169B, where the process kernel 302C determines whether process P can be abbreviated to P '. If the answer in decision block 1169B is YES, then the process kernel 302C returns a process expression. Is reduced to (NEW X) P '. See block 1169C. The method 1100 then proceeds to terminal L6. If the answer at decision blocks 1169A and 1169B is no, then the method flow proceeds to another decision block 1167A. Here, process kernel 302C is a process expression It is determined whether or not to include X [P]. If the answer is yes, the method 1100 proceeds to another decision block 1167B. Process kernel 302C determines whether process P can be reduced to another process P '. See decision block 1167B. If the answer to decision block 1167B is yes, the method flow proceeds to another continuing terminal ("terminal L3"). If the answer at decision blocks 1167A, 1167B is no, the method 1100 proceeds to another continuing terminal ("terminal L4").

From terminal L3, method 1100 proceeds to block 1167C, where process kernel 302C is a process expression. Is abbreviated to X [P ']. The method flow then proceeds to terminal L6. From terminal L4 (FIG. 11u), the method flow proceeds to another decision block 1165A, where the process kernel 302C is a process expression. Determine whether this process contains X [Q] .P. If the answer to decision block 1165A is yes, then process kernel 302C may query query Q in decision block 1165B. Determines whether it has an equivalent relationship with another query in. term Means a query that has nothing at its head (the query's head contains no terms). Its body is a term that represents a list of constraints or binding relationships (such as conditions that bind a port to a port), or a term that represents a binding relationship to a list of values associated with a list of local variables from a list of local variables. It includes.

If the answer to decision block 1165B is yes, then process kernel 302C also determines whether query Q is in standard form. See decision block 1165C. If the test at decision block 1165C is YES, then the process kernel 302C returns the process expression. Form To the process of See block 1165D. term silver This is a lifted query equivalent to, as described above in FIGS. 10A-10C. Lifted query Is a query that does not include his head term, and his body is a globally known constraint. Contains the binding relationships described in the list. term Silver pharmaceutical Local variable while the constraint term in the list of The value of each local variable in the list of The process of substituting the corresponding values in the list of. In summary, the process My query is Q Process is equal to and query Q is in standard form Form Can be evolved into the process of. The method 1100 then proceeds to terminal L6.

If the answer at decision blocks 1165A-1165C is no, then the method 1100 enters another decision block 1163A. Process Kernel 302C is a process expression It is determined whether or not P ₀ ′ includes P ₀ having an equivalent relationship. See decision block 1163A. If the answer is yes, the method 1100 proceeds to another continuing terminal ("terminal L5"). If the answer to decision block 1163A is no, the method 1100 proceeds to terminal L6.

From terminal L5 (FIG. 11V), the method 1100 proceeds to decision block 1163B, where the process kernel 302C determines whether P ₀ ′ can be reduced to P ₁ ′. If the answer is yes, the process kernel (302C) determines whether the process P ₁ 'is it has the equivalent related to the process P _1. See decision block 1163C. If the test at decision block 1163C is YES, process kernel 302C shortens process P ₀ to process P ₁ . See block 1163D. The method 1100 then proceeds to terminal L6. If the answer at decision blocks 1163B, 1163C is no, the method 1100 also proceeds to terminal L6.

From terminal L6 (FIG. 11V), the method 1100 proceeds to another decision block 1161, where the process kernel 302C determines whether there are more process expressions to be analyzed under the operational semantic rules of the language 400. Examine to find out. If the answer is no, the method flow proceeds to termination terminal M. If the answer to decision block 1161 is yes, the method 1100 proceeds to another continuing terminal ("terminal L7"). From terminal L7, the method 1100 loops back to block 1175 and the method steps described above are repeated.

While the preferred embodiments of the invention have been illustrated and described, it will be appreciated that various changes may be made without departing from the spirit and scope of the invention.

Appendix

semantics

The semantics of the language are provided in a set of SOS-style abbreviations. For simplicity, a more compact and completely infix version of the syntax, often called a calculus, is introduced. The reason why a series of equivalence rules are enforced on these constructs is because they distinguish between processes that are too granular. The abbreviation rule is closed on this equivalence.

Arithmetic structure style syntax

The correspondence between the syntax seen by the programmer and the infix (model-level) syntax should be obvious, but is given in the table below for completeness. Note that prefix syntax attempts to circumvent its verbosity by providing syntactic sugar, such as block form. This form allows the programmer to specify the prefix of several actions that will be executed sequentially beforehand. The table below provides only minimal information for inferring edits, rather than listing all of these forms of overall edits. This selection corresponds to causing the left column to be a conversion of the right column.

Program-level syntax Model-level syntax {} 0 sequence {block {x [Q];} P} x [Q] .P new (x) {P} (new x) P select {case x [Qi]: Pi} parallel {P P} P | P schedule S (...) {... call S (...);} ! P

Note: The lifted query form is not available at the user level in the current prefix syntax. However, it will be available in future versions.

Program-level syntax Model-level syntax T: =: T; T: =: T x x x ^ x ^ ^ x ^ x ~ T ~ T T * T T * T T # T T # T (x *) [left: Q | right: Q] <x *> (Q, Q) in (left, x) in (right, x) inl (x) inr (x) (x *) [Q] <x *> (Q) ? T ? T T @ T T @ T top / bottom / _ / port y top | bottom | _ | name y

Structural equivalence

As mentioned above, the syntax makes too many distinctions. The syntax makes no distinction about which term appears, for example, in ": =:". To eliminate this unnecessary distinction, we introduce structural equivalence.

In the case of a query, we do this using a query context, which is a query that has a place in it to insert a condition. In the case of a process, we do this explicitly.

For readers who are familiar with logarithmic processes, these equations are commonplace. One interesting case is as follows. If the query is standard and there are conditions in its body, these conditions are actually the equation between ports or the equation between local variables and their values. On lifting, the local variable is replaced by its value and goes into continuation. The equation between ports acts as a process to implement some sort of explicit substitution when present in the lifted query.

Standard

Abbreviation rule

Explanation

MATCH

Match rules are actually a rule schema. Every time a literal meets his duel, they disappear. This translates to success because no further checking is required.

CUT

Identifiers can be intuitively thought of as wires. When two terms are at each end of the wire, you remove the wire and plug the two terms directly into each other. It is worth recalling that the linear type ensures that the identifier appears exactly twice in the well-typed term.

TENSOR-PAR

When the provision of the tuple meets the [sic] requirement for the tuple, the corresponding locations are wired to each other.

WITH-PLUS

When the provision of the menu ( withClaim form) satisfies the demand for selection ( injectClaim form), the selection is made. This allows the selected option to be wired to the constraints of the request.

READ

When the provision of the recording ofCourseClaim satisfies the need for playback ( whyNotClaim ), the data for the recording is wired to the constraints of the request.

COPY

When the provision of the recording satisfies the requirement for copying ( contractClaim ), the individual copies are wired to the individual constraints of the request.

DISCARD

When the provision of the recording satisfies the request (" _ ") to discard the recording, the recording is discarded.

CONTEXT

When a set of conditions evolves in some way, they evolve that way in terms of the query body.

CLEANUP

When one end of the wire, that is, one occurrence of the [sic] identifier is at the head of the query (some term in the query) and the other end is at the body, the term to which the identifier is bound can be replaced into the head.

Definition 3.2.1. Is permutation If you say this query, Is obtained.

Definition 3.2.2. ego Ramen, Is obtained.

Definition 3.2.3. Literal Form for The constraint of If it is a failure.

Definition 3.2.4. Query Q And fail only if Q 'includes a failure.

Definition 3.2.5. Constraint c is Is only in short for query Q.

Definition 3.2.6. Query Q is in standard form only if all of its constraints are non-abbreviable and Q is not a failure (in other words, in canonical form).

COMM

If two queries each have a matching term at some point within their head and the corresponding CUT query evolves into a query that cannot proceed any further, but is not a failure, the two processes that placed these queries in the same queue are allowed to communicate. do. Each continuation waits on completion of the abbreviated query.

PAR

If a process can go on its own, it can still go on with another process and parallel synthesis.

NEW

If a process can proceed on its own, it can still proceed even if one of its ports is no longer available for interaction with the outside world.

LIFT

A query without a term at the head has only the condition of binding a port to a port or a local variable to a value. This query can be lifted. Upon lift, local variables are replaced outside the body of the continuation.

The equation remaining after the local variable has been replaced and lost is between the ports. These queries then become wires between processes or equalized ports that act as some sort of explicit substitution.

EQUIV

Evolution is closed for equivalence.

Claims (108)

A computer system that processes a set of modules of protocol-based applications to provide services over a network connection. Computer readable means for storing a program comprising an expression written in a process based language to represent a protocol based application as a process, and A process kernel that executes the expression in the program, The expression specifies the interaction of processes by allowing named data organizational schemes written in a customizable tag-based language to be exchanged as processes between processes, and the named data organizational schemes transmit and transfer the named data organizational schemes. A computer system that is bound to the scope of receiving processes. The method of claim 1, Further comprising an operating system kernel coupled to the process kernel, The operating system kernel provides an allocation and use of hardware resources including memory, central processing unit time, disk space, and peripherals. The method of claim 1, Further comprising a device driver coupled to the process kernel, The device driver provides a software component that enables the computer system to communicate with hardware devices. The method of claim 1, And a directory framework that provides a method for finding and registering web services on the Internet. The method of claim 4, wherein Further comprising a discovery component within the directory framework, And the discovery component acts as an intermediary between processes to find the desired web service. A computer executable method of processing a collection of modules of protocol-based applications to provide services over a network connection, Representing a protocol-based application as a process when a process expression in a program written in a process-based language is executed, Expressing, as a process, how the named data is constructed in a customizable tag-based language when the query expression is executed, and Causing processes to communicate when processes send to or receive from the queue as a query for the named data organization; The named data organization method is bound to a range of processes for transmitting or receiving the named data organization method. The method of claim 6, Further comprising interacting with the operating system kernel, The operating system kernel provides for the allocation and use of hardware resources including memory, central processing unit time, disk space, and peripherals. The method of claim 6, Further comprising interacting with the device driver, The device driver is a computer executable method that enables a computer system on which the method is implemented to communicate with hardware devices. The method of claim 6, Finding a protocol based application through a directory framework and registering as a web service on the Internet. The method of claim 9, Mediating between processes to find a desired web service by a discovery component in the directory framework. A computer readable medium having computer executable instructions for performing a method of processing a collection of modules of a protocol-based application to provide a service over a network connection, the method comprising: The method, Representing a protocol-based application as a process when a process expression in a program written in a process-based language is executed, Expressing, as a process, how the named data is constructed in a customizable tag-based language when the query expression is executed, and Allowing processes to communicate when processes send to or receive from the queue as a query for the named data organization; And the named data organization method is bound to a range of processes for transmitting or receiving the named data organization method. The method of claim 11, The method further comprises interacting with an operating system kernel, And said operating system kernel provides allocation and use of hardware resources including memory, central processing unit time, disk space, and peripherals. The method of claim 11, The method further comprises interacting with a device driver, The device driver is a computer readable medium that enables a computer system on which the method is implemented to communicate with hardware devices. The method of claim 11, The method further comprises finding and registering a protocol based application through a directory framework as a web service on the Internet. The method of claim 14, The method further comprises mediating between processes to find a desired web service by a discovery component in the directory framework. Query virtual machines that define queries and govern the interaction between queries and queues in programs written in a process-based language, A process virtual machine defining a process comprising a protocol based application in said program and governing the interaction between the processes, and A computer system comprising a reactive virtual machine that defines valid interactions between queries, queues, and processes and also governs interactions between queries, queues, and processes by interpreting queries as processes. The method of claim 16, And a transition virtual machine that separates the query virtual machine, the process virtual machine, and the reactive virtual machine from other system software components of the computer system. The method of claim 16, A queue is a computer system that includes a database, channel, or structured store that allows processes running at different times or concurrently to communicate across heterogeneous networks and systems that may be temporarily offline. The method of claim 16, A query is a computer system that includes instructions written in a data manipulation language that assembles and disassembles other queries, manipulates queues, and detects patterns in the queries. The method of claim 16, A process includes a computing entity having the ability to evolve by performing an action or by allowing other processes to evolve. A computer executable method of compiling an expression written in a process-based language, Parsing the expression to obtain syntax elements representing a queue, a set of queue delimiters, a query, a sequence delimiter, and other actions, and Interpreting the expression as a process in which the first action is to send the query to the queue as another process and then continue with another action, Wherein the query comprises a configuration scheme formed from a customizable tag-based language that contains data and describes the data. The method of claim 21, A portion of the expression representing the query includes a head and a body, The heads are separated by first and second query head delimiters, And wherein the body is distinguished by first and second query body delimiters. The method of claim 22, And at least zero query conditions are included between the first and second query head delimiters. The method of claim 22, And at least zero constraints are included between the first and second query body delimiters. The method of claim 24, Each constraint is a binding that defines a relationship between one query condition and another query condition. The method of claim 25, A query condition is a computer executable method that includes literals. The method of claim 25, A query condition is a computer executable method that includes a complementary literal. The method of claim 25, The query condition includes a discarder. The method of claim 25, The query condition includes the name of the variable. The method of claim 25, A query condition is a computer executable method that includes a variable. The method of claim 25, A query condition is a computer executable method comprising an inversion of a query condition. The method of claim 25, A query condition is a computer executable method comprising a tuple of query conditions. The method of claim 25, The query condition comprises a complementary tuple of query conditions. The method of claim 25, The query condition includes a second query having zero or more variables in the head, and third and fourth queries separated by commas in the body. The method of claim 34, wherein The query condition includes a left injector that takes a variable as an argument. The method of claim 25, The query condition includes a right injector that takes a variable as an argument. The method of claim 25, The query condition includes a fifth query having zero or more variables in the head and a sixth query in the body. The method of claim 37, The query condition includes a read operator that operates on the query condition. The method of claim 37, A query condition is a computer executable method that includes a copy operator that operates on a query condition. The method of claim 21, A portion of the expression representing the process includes an inactivity operator, The inactivity operator allows a inactivity of the process to be expressed. The method of claim 21, A portion of the expression representing the process includes a summation operator that sums up a series of processes, And the summing operator allows the process to continuously represent the choices that the process can select from the series of processes. The method of claim 21, A portion of the expression representing the process includes a new operator, And the new operator allows a generation of a name bound to the process to be represented. The method of claim 21, A portion of the expression representing the process includes a parallel operator, The parallel operator is a computer executable method that allows two processes executed in parallel to be represented. The method of claim 21, A portion of the expression representing the process includes a replication operator, And the replication operator enables expression of the infinite behavior of the process. The method of claim 21, Wherein a portion of the expression representing the process comprises a second queue, a second set of queue delimiters, and a process. The method of claim 21, A portion of the expression representing the process comprises a lifted query. A computer readable medium having computer executable instructions for performing a method of compiling an expression written in a process-based language, the method comprising: The method, Parsing the expression to obtain syntax elements representing a queue, a set of queue delimiters, a query, a sequence delimiter, and other actions, and Interpreting the expression as a process in which the first action is to send the query to the queue as another process and then continue with another action, And the query comprises a configuration scheme formed from a customizable tag-based language that contains data and describes the data. The method of claim 47, A portion of the expression representing the query includes a head and a body, The heads are separated by first and second query head delimiters, And the body is distinguished by first and second query body delimiters. The method of claim 48, And at least zero query condition is included between the first and second query head delimiters. The method of claim 48, And zero or more constraints are included between the first and second query body delimiters. 51. The method of claim 50, Each constraint is a binding that defines a relationship between one query condition and another query condition. The method of claim 51, A query condition is a computer readable medium containing a literal. The method of claim 51, A query condition is a computer readable medium containing a complementary literal. The method of claim 51, The query condition is a computer readable medium comprising a discarder. The method of claim 51, The query condition includes a name of the variable. The method of claim 51, The query condition comprises a variable. The method of claim 51, The query condition comprises a inversion of the query condition. The method of claim 51, A query condition is a computer readable medium containing a tuple of query conditions. The method of claim 51, The query condition comprises a complementary tuple of query conditions. The method of claim 51, The query condition includes a second query having zero or more variables in the head, and third and fourth queries separated by commas in the body. The method of claim 60, The query condition includes a left injector that receives a variable as an argument. 62. The method of claim 61, The query condition includes a right injector that takes a variable as an argument. 62. The method of claim 61, The query condition includes a fifth query having zero or more variables in the head and a sixth query in the body. The method of claim 63, wherein The query condition is a computer readable medium including a read operator that operates on the query condition. The method of claim 63, wherein A query condition is a computer readable medium comprising a copy operator that operates on a query condition. The method of claim 47, A portion of the expression representing the process includes an inactivity operator, The inactivity operator is a computer readable medium that enables the inactivity of the process to be expressed. The method of claim 47, A portion of the expression representing the process includes a summation operator that sums up a series of processes, And the summing operator allows the process to continuously represent the choices that the process can select from the series of processes. The method of claim 47, A portion of the expression representing the process includes a new operator, And the new operator allows a generation of a name bound to the process to be represented. The method of claim 47, A portion of the expression representing the process includes a parallel operator, And the parallel operator allows two processes executed in parallel to be represented. The method of claim 47, A portion of the expression representing the process includes a replication operator, The replication operator is such that the infinite behavior of the process can be expressed. The method of claim 47, And wherein a portion of the expression representing the process comprises a second queue, a second set of queue delimiters, and a process. The method of claim 47, A portion of the expression representing the process comprises a lifted query. A computer executable method of executing a set of equation laws that govern the structural equivalence of an expression written in a process-based language. Parsing a first expression describing that the query is running in parallel with the process, wherein the query has a head and a body, the head is empty and the body includes a first name bound to a second name Parsing step, and Interpreting the first expression as structurally equivalent to a second expression, The second expression describes that the query is running in parallel with the process when the query is in canonical form, wherein each occurrence of the first name in the process is replaceable with the second name. Computer executable method. The method of claim 73, And the query is canonical only if all of the constraints in the body of the query are irreducible and the query is not a failure. The method of claim 74, wherein The constraint is non-abbreviable in the query only if there is a second query that causes the constraint to be an element of the second query when the query is abbreviated to the second query. The method of claim 74, wherein And the query is a failure only if the query is shorthand to a second query and the second query includes a failure. 77. The method of claim 76, The constraint is defined as a first literal that the constraint is bound to a second literal and fails if the first literal is not a complement of the second literal. A computer readable medium having computer executable instructions for performing a method of executing a set of equation laws that govern the structural equivalence of an expression written in a process-based language, The method, Parsing a first expression describing that the query is executing in parallel with the process, wherein the query has a head and a body, the head is empty and the body includes a first name bound to a second name Parsing step, and Interpreting the first expression as structurally equivalent to a second expression, The second expression describes that the query is running in parallel with the process when the query is in canonical form, wherein each occurrence of the first name in the process is replaceable with the second name. Computer-readable medium. The method of claim 78, And the query is standard only if all of the constraints in the body of the query are irreducible and the query is not a failure. The method of claim 79, The constraint is non-abbreviated in the query only if there is a second query that causes the constraint to be an element of the second query when the query is abbreviated to the second query. The method of claim 79, And the query is a failure only if the query is shorthand to a second query and the second query includes a failure. 82. The method of claim 81 wherein The constraint is defined as a first literal that the constraint is bound to a second literal and is a failure if the first literal is not a complement of the second literal. A computer executable method of executing a set of operational semantics rules that govern the meaning of expressions written in a process-based language. Parsing a first expression describing that the process is optional of two processes, wherein the first of the two processes has a first query sent to the queue and thereafter the first process performs a first series of operations. A parsing step expressing continuation, wherein a second of said two processes is a second query sent to said queue and thereafter said second process continues a second series of operations; and Shortening the first expression to a second expression, wherein the second expression is a third query is sent to the queue if the third query is a canonical form and thereafter the first process is in parallel with the second process. A computer executable method comprising abbreviation steps describing execution. 84. The method of claim 83, The third query is an abbreviation of the binding of two conditions, The first of two conditions comprises the application of a first permutation function to said first query, And the second condition comprises applying a second permutation to the second query. 84. The method of claim 83, The third query is canonical only if all of the constraints in the body of the third query are irreducible and the third query is not a failure. 86. The method of claim 85, The constraint is non-abbreviable in the third query only if the fourth query exists that causes the constraint to be an element of the fourth query when the third query is abbreviated to the fourth query. 86. The method of claim 85, And the third query is a failure only if the third query is shorthand to a fourth query and the fourth query includes a failure. 88. The method of claim 87 wherein The constraint is defined as a first literal that the constraint is bound to a second literal and fails if the first literal is not a complement of the second literal. A computer readable medium having computer executable instructions for performing a method of executing a set of operational semantics rules that govern the meaning of expressions written in a process-based language. The method, Parsing a first expression describing that the process is optional of two processes, wherein the first of the two processes has a first query sent to the queue and thereafter the first process performs a first series of operations. A parsing step expressing continuation, wherein a second of said two processes is a second query sent to said queue and thereafter said second process continues a second series of operations; and Shortening the first expression to a second expression, wherein the second expression is a third query is sent to the queue if the third query is a canonical form and thereafter the first process is in parallel with the second process. A computer readable medium comprising the abbreviation step of describing execution. 91. The method of claim 89 wherein The third query is an abbreviation of the binding of two conditions, The first of two conditions comprises the application of a first permutation function to said first query, And the second condition includes the application of a second permutation to the second query. 91. The method of claim 89 wherein And the third query is standard only if all of the constraints in the body of the third query are irreducible and the third query is not a failure. 92. The method of claim 91, The constraint is non-abbreviated in the third query only if there is a fourth query that causes the constraint to be an element of the fourth query when the third query is abbreviated to the fourth query. 92. The method of claim 91, And the third query is a failure only if the third query is shorthand to a fourth query and the fourth query includes a failure. 95. The method of claim 93, The constraint is defined as a first literal that the constraint is bound to a second literal and is a failure if the first literal is not a complement of the second literal. A computer executable method of executing a set of operational semantic rules that govern the meaning of expressions written in a process-based language. Parsing a first expression, wherein the first expression describes a first process and the first operation of the first process is to send a query to the queue, after which the first process continues the second process , And Shortening the first expression to a second expression, the second expression including a shortening step describing that the lifted query is executed in parallel with the second process if the first query is standard. Possible way. 97. The method of claim 95, And the first query is structurally equivalent to another query having a body that is an empty head and a list of constraints. 97. The method of claim 96, Wherein each constraint in the list of constraints is a binding between two names. 97. The method of claim 95, And the first query is canonical only if all of the constraints in the body of the first query are unabbreviated and the first query is not a failure. 99. The method of claim 98, The constraint is non-abbreviated in the first query only if there is a second query that causes the constraint to be an element of the second query when the first query is abbreviated to the second query. The method of claim 99, wherein And wherein the first query is a failure only if the first query is shorthand to a second query and the second query includes a failure. 101. The method of claim 100, The constraint is defined as a first literal that the constraint is bound to a second literal and fails if the first literal is not a complement of the second literal. A computer readable medium having computer executable instructions for performing a method of executing a set of operational semantic rules that govern the meaning of an expression written in a process-based language, Parsing a first expression, wherein the first expression describes a first process and the first operation of the first process is to send a query to the queue, after which the first process continues the second process , And Shortening the first expression to a second expression, the second expression including a shortening step describing that the lifted query is executed in parallel with the second process if the first query is standard. Media available. 103. The method of claim 102, And the first query is structurally equivalent to another query having a body that is an empty head and a list of constraints. 103. The method of claim 103, Wherein each constraint in the list of constraints is a binding between two names. 103. The method of claim 102, And the first query is standard only if all of the constraints in the body of the first query are non-abbreviated and the first query is not a failure. 105. The method of claim 105, The constraint is nonabbreviated in the first query only if there is a second query that causes the constraint to be an element of the second query when the first query is abbreviated to the second query. 105. The method of claim 105, And the first query is a failure only if the first query is shorthand for a second query and the second query includes a failure. 107. The method of claim 107 wherein The constraint is defined as a first literal that the constraint is bound to a second literal and is a failure if the first literal is not a complement of the second literal.