# US 2006/0136921 A1 · Architecture for a computer-based development environment with self-contained components and a threading model

> Agents: this data is available as JSON from the patentgrep API and MCP server — see https://patentgrep.com/llms.txt

- Number: US 2006/0136921 A1
- Document ID: US20060136921A1
- Status: Published application
- Kind: A1
- Application number: 11/283,713
- Filed: 2005-11-22
- Published: 2006-06-22
- Earliest claimed: 2004-11-24
- Assignees: Siemens Aktiengesellschaft
- Inventors: Detlef Becker; Karlheinz Dorn; Vladyslav Ukis; Hans-Martin Von Stockhausen
- Web page: https://patentgrep.com/patent/US20060136921A1

## CPC

- G06F 9/4806: {Task transfer initiation or dispatching}
- G06F 8/00: Arrangements for software engineering (testing or debugging G06F11/36; administrative, planning or organisation aspects of software project management G06Q10/06)
- G06F: ELECTRIC DIGITAL DATA PROCESSING (computer systems based on specific computational models G06N)

## Abstract

A method, a device and a system arrangement are disclosed for generating self-contained software components having in each case synchronous and/or asynchronous interfaces with an internal threading model. The concept disclosed enables all necessary synchronization mechanisms to be provided automatically. The concept is based on an asynchronous operation manager used to divert callbacks from a called component into a calling component.

## Claims

### Claim 1

A method for providing an architecture for at least one of a software based and hardware-based process, the process being dividable over a at least one of plurality of components and over a plurality of parallel executing threads, comprising:
automatically defining at least one unit to be protected which must be protected against concurrent accesses from a plurality of threads; and
synchronizing concurrent accesses to the at least one unit to be protected to thereby automatically protect the at least one unit to be protected.

### Claim 2 (depends on 1)

The method as claimed in claim 1, wherein the concurrent accesses to the unit to be protected are synchronized by:
directly performing an access of a calling thread to data of a called thread, and
indirectly performing a reciprocal access of the called thread to data of the calling thread and diverting it into an access within the calling thread.

### Claim 3 (depends on 1)

The method as claimed in claim 1, wherein a plurality of components are run in one thread, which components in turn include subcomponents, and wherein each subcomponent is always called by the same thread.

### Claim 4 (depends on 1)

The method as claimed in claim 1, wherein at least one of the components and subcomponents of a called thread are passive and do not themselves execute any direct reciprocal accesses.

### Claim 5 (depends on 1)

The method as claimed in claim 1, wherein the access is performed from at least one of a component and from a subcomponent.

### Claim 6 (depends on 1)

The method as claimed in claim 1, wherein the method is version-independent.

### Claim 7 (depends on 1)

The method as claimed in claim 1, wherein the processing of the reciprocal access of the called thread to data of the calling thread is performed on a higher hierarchical level in each case.

### Claim 8 (depends on 1)

The method as claimed in claim 1, wherein the method is used recursively for components on different hierarchical call levels.

### Claim 9 (depends on 1)

The method as claimed in claim 1, wherein the method includes a provider strategy which enables an exchange of an implementation of a subcomponent at runtime.

### Claim 10 (depends on 9)

The method as claimed in claim 9, wherein a component is also extendable at runtime by adding at least one further subcomponent.

### Claim 11 (depends on 1)

The method as claimed in claim 1, wherein the subcomponents are at least one of self-contained modules and exchangeable at runtime.

### Claim 12 (depends on 1)

The method as claimed in claim 1, wherein the method further comprises:
automatic generation of at least one of software code for the process for the subcomponents with their interfaces and of a repository with at least one of the components and subcomponents required in each case.

### Claim 13 (depends on 12)

The method as claimed in claim 12, wherein a type is selectable for the interface of the component, and wherein a choice between a synchronous and an asynchronous interface is selectable.

### Claim 14

A device for providing an architecture for at least one of a software-based and hardware-based process, the process being dividable over at least one of plurality of components and over a plurality of parallel executing threads, the device comprising:
at least one definition unit to define units to be protected as units that need to be protected against concurrent accesses from a plurality of threads; and
at least one asynchronous operation manager to automatically protect the units to be protected by synchronizing concurrent accesses to units to be protected.

### Claim 15 (depends on 14)

The device as claimed in claim 14, wherein the asynchronous operation manager synchronizes the concurrent accesses to the units to be protected by directly performing an access of a calling thread to data of a called thread, and by indirectly performing a reciprocal access of the called thread to data of the calling thread via the asynchronous operation manager and diverting it into an access within the calling thread.

### Claim 16 (depends on 14)

The device as claimed in claim 14, wherein a plurality of components run in one thread, which components in turn include subcomponents, and wherein each subcomponent is always called by the same thread.

### Claim 17 (depends on 14)

The device as claimed in claim 14, wherein at least one of the components and subcomponents of a called thread are passive and do not themselves execute any direct reciprocal accesses.

### Claim 18 (depends on 14)

The device as claimed in claim 14, wherein the access is performed from at least one of a component and a subcomponent.

### Claim 19 (depends on 14)

The device as claimed in claim 14, wherein the device is version-independent.

### Claim 20 (depends on 14)

The device as claimed in claim 14, wherein the processing of the reciprocal access of the called thread to data of the calling thread is performed on a higher hierarchical level in each case.

### Claim 21 (depends on 14)

The device as claimed in claim 14, wherein the device includes a device nested within it.

### Claim 22 (depends on 14)

The device as claimed in claim 14, wherein the device includes a provider which is intended to enable a selection and an exchange of an implementation of a subcomponent at runtime.

### Claim 23 (depends on 22)

The device as claimed in claim 22, wherein a component also is extendable at runtime by adding at least one further subcomponent.

### Claim 24 (depends on 22)

The device as claimed in claim 22, wherein the subcomponents are at least one of self-contained modules and exchangable at runtime.

### Claim 25 (depends on 14)

The device as claimed in claim 14, wherein the device includes an additional module:
a code generator for the automatic generation of at least one of software code for the process for the subcomponents with their interfaces and a repository with at least one of the components and subcomponents required in each case.

### Claim 26 (depends on 14)

The device as claimed in claim 14, wherein a type is selectable for the interface of the component, and wherein a choice between a synchronous and an asynchronous interface is selectable.

### Claim 27

A system arrangement for providing an architecture for at least one of a software-based and hardware-based process, the process the process being dividable over at least one of plurality of components and over a plurality of parallel executing threads, the system arrangement comprising:
at least one component to execute at least some of the functionality of the process and has a selectable interface;
at least one definition unit to define units to be protected as units that need to be protected against concurrent accesses from a plurality of threads;
at least one asynchronous operation manager to automatically protect the units to be protected by synchronizing concurrent accesses to units to be protected; and/or
a code generator to automatically generate software code for the process.

### Claim 28 (depends on 2)

The method as claimed in claim 2, wherein a plurality of components are run in one thread, which components in turn include subcomponents, and wherein each subcomponent is always called by the same thread.

### Claim 29 (depends on 2)

The method as claimed in claim 2, wherein at least one of the components and subcomponents of a called thread are passive and do not themselves execute any direct reciprocal accesses.

### Claim 30 (depends on 2)

The method as claimed in claim 2, wherein the access is performed from at least one of a component and from a subcomponent.

### Claim 31 (depends on 1)

The method as claimed in claim 1, wherein the method is not dependent on one version of a component.

### Claim 32 (depends on 15)

The device as claimed in claim 15, wherein a plurality of components run in one thread, which components in turn include subcomponents, and wherein each subcomponent is always called by the same thread.

### Claim 33 (depends on 14)

The device as claimed in claim 14, wherein the device is not dependent on one version of a component.

### Claim 34 (depends on 1)

A computer program, adapted to, when executed on a computer, cause the computer to carry out the method as claimed in claim 1.

### Claim 35 (depends on 34)

A computer program product, including the computer program of claim 34.

### Claim 36 (depends on 1)

A computer readable medium including program segments for, when executed on a computer, causing the computer to implement the method of claim 1.
