WO2011076913A1

WO2011076913A1 - Method for detecting and processing data while considering metadata

Info

Publication number: WO2011076913A1
Application number: PCT/EP2010/070626
Authority: WO
Inventors: Mario Neugebauer
Original assignee: Ubigrate Gmbh
Priority date: 2009-12-23
Filing date: 2010-12-23
Publication date: 2011-06-30

Abstract

The invention relates to a method for detecting and processing data while considering metadata comprising additional information about the actual data, wherein a program code comprising program instructions is converted into a compiled code prior to being executed in a processing unit, wherein the object of the invention is to provide metadata management by means of which the processing of data in conjunction with metadata is made more simple. Said object is achieved in that it is determined in a first process step which variables present in the program code are associated with metadata, that the locations in the compiled code at which operations using the determined variable are performed are derived in a second process step and said locations are labeled by means of a joinpoint, and that the code is modified at the locations labeled by joinpoints by means of a function for processing the compiled code (advice) in a third process step, such that the program instructions are executed as a function of the metadata.

Description

Method for data acquisition and processing taking into account metadata

The invention relates to a method for data acquisition and processing in consideration of metadata, which contain additional information to the actual data, in which a program instructions containing

Program code before its execution in one

Processing unit is converted into a compiled code.

The invention is in the field of data acquisition and processing, for example, in measuring and testing devices

in which metadata must be generated during measurement processes and taken into account in the subsequent processing process.

When recording and processing readings in

Data processing or computing systems are becoming more common

Additional information about the actual data, the

so-called metadata, generated and carried in the processing of data.

Such metadata are, for example, units of measure that are attached to the variables or value. For example, a length measurement of 5 meters consists of the value "5" and the additional information "meter". These

Additional information is the unit and is referred to below as metadata.

Other metadata may include the time of the measured value recording, measurement circumstances, tolerances of the measuring device or information about the measuring direction, among others. This metadata is highly relevant to the correct processing of the data. Like the actual measured values, they must be subjected to processing, for example by means of a data processing system. In the simplest case, this is a conversion of units of measure

For example, only values of the same unit (for example, only meters) are to be processed together, for example to

add. But it can also be calculated new units of measurement, z. For example, a speed in meters per second when dividing appropriate values.

In processing algorithms, these metadata have to be carried along and thus also changed analogously to the actual values, which leads to an increased outlay on the

Data processing leads. So-called operators and value objects are known from the prior art.

Operators are constructs that can be used to create new objects from objects. These constructs can also be present in programming languages. So usually the operator "+" is an example, he is in almost all

Programming languages with the meaning of the addition of the preceding or underlying values occupied. Operators are firmly implemented.

The C ++ programming language is an exception in terms of operators. In C ++ the operators are freely definable with the so-called operator overload. So that can

For example, the conversion of the operator "+" to the case of assembling strings will be applied.

Operators will be during the time of translation of the

Program codes translated directly into machine code. This determines how the defined operators are executed and how the objects before and after form a new object. For values, objects, so-called value objects, can be formed, which in turn, according to the principle of

Object-oriented programming functions can be defined. The actual value is kept in a property of the object.

If metadata is to be transported together with the value, this metadata must be included as an additional property of the object. The operation is then realized by the function on the object, the

Function on the metadata defined as additional property. This allows you to edit the metadata, for example the length unit meters, in parallel to the values.

The entrainment and processing of metadata can be done in

Program code libraries are implemented. The object definitions contained in it contain properties, both for the values and for the metadata of the objects.

With operators in the programming language C ++ there is a possibility available to the metadata management

in principle. There are, however, exist

Disadvantages, so use in certain

Use cases is not possible.

Operators may be implemented within program code libraries. Within this program code library, the operators are already translated.

This means, for example, that the operation "string + string2" already in the concatenation of

Character string has been translated with string 2, the actual execution of the concatenation then being present as an executable machine code. The decisive one

Disadvantage is that the operator is not overwritable. The machine code can not be subsequently optimized automatically for metadata acquisition and processing become .

In addition, there is another disadvantage. The operators consider metadata at the time of translation of the program code into machine code. After that are no

Clues exist that can be used to interweave additional dimensions related to the metadata. The

Operators can only take effect at compile time.

All values in a metadata collection

or processing are involved, must via the

special value objects are transported. These

Value objects must also be used throughout the program code to maintain consistency. Simplifications of the way that the value object is based on primitive data types

mapped, for example, as an integer to "int", lead to the complete loss of all additional information about the metadata.

On primitive data types, a set of basic operators are usually already specified and implemented.

These operators can not be applied to value objects. If you want to apply the base operators to the value objects, the latter must be new as functions

implemented as, for example

Obj ect. add (...) for "+".

Similarly, basic functions must be completely new

be implemented. This creates a high

Development effort.

If value objects are used in the program code, the program code is bound to these specific value objects. Primitive data types that transport only the values must be transformed via an individual connection to the value objects. Value objects are permanently implemented in the program code. They can not be switched on or off, for example for the purpose of increasing the performance of the temporary data processing without consideration of the metadata. When combining different metadata types, for example, considering

Length units and additional temporal aspects, the development of a combination is very complex. A higher-level value object must be developed in which the metadata handling of both value objects to be combined is carried out. Newly added metadata aspects must again be inserted in this way. In addition to the higher development effort, a new translation of the program code into machine code is required. The invention is based on the object

Specify metadata management that simplifies the processing of data associated with metadata.

According to the invention, the object is achieved in a method for data acquisition and processing in consideration of metadata in that in a first

The method step is determined by which variables contained in the program code metadata are assigned, that are determined in a second step, the locations in the compiled code on which operations are performed with the specified variables and that this

Be characterized by means of a Joinpoints that in a third process step by means of a function for handling the compiled code (Advice) at the points marked by the Joinpoints the code is modified such that an execution of the

Program instructions depending on the metadata is done.

For data acquisition and processing, taking metadata into account, the program code is made known once. which variables are metrics that include metadata. This can be done, for example, by calling an additional function. These variables are stored in a central registry with their associated metadata and are linked to metadata such as "m" or "s".

Subsequently, through the processing logic, the

Joinpoints, that is, all points in the program code where

Operations performed with the registered variables are determined. Additions to the program code are made at these join points. These actually elementary operations are thereby for example by a

Function call replaced in the processing logic. In such an external function, it is now possible, the replaced elementary operation taking into account the to the

Perform variable (s) related metadata.

The invention thus facilitates the carrying of the metadata without significant changes having to be made in the program code (high-level language, byte code or even executable code). The data processing remains transparent, with the metadata being carried automatically.

In one embodiment of the invention, it is provided that the modification of the code takes place before, after or exactly at the point marked by the joinpoint in the compiled code.

The modification of the code according to the invention can, with respect to the determined join points, take place exactly at the points of the join points, before this point, after this point or before and after this point. In one embodiment of the invention it is provided that the

Modification of the code by means of a jump instruction, a replacement of code parts or an addition of

Code parts done. The modification of the code can, for example, by calling another code section by means of a

Jump instruction, by replacing the code with another code or by adding another code.

In one embodiment of the invention it is provided that the modification of the code during the term of the

Program can be switched on and off.

Since the advices, ie an additional code to be executed at the point of a joinpoint, are not until shortly before the

The actual execution of the compiled program code may be inserted at the joinpoints

Metadata management at runtime on or off. As a result, for example, metadata management can only be activated for tests or for metadata-critical operations.

This results in the following advantages:

Simplify handling of metadata in

reading systems

Creating transparency in metadata management, so no significant changes to the

Implemented algorithms are necessary on / off switchable at runtime, without retranslation of high-level language code

Error detection and correction during measured value processing Easy combination of several metadata types

The invention will be explained in more detail with reference to an embodiment ^¬ example. In the associated

Drawing shows Fig. 1 is an illustration of the procedure.

In the following, general introductory basics of aspect-oriented programming (AOP) are explained.

A program code is generally intended to be specific

Implement system functionalities. In addition, additional tasks of the program may be important,

For example, logging expenses when reaching

characteristic points in program execution.

The latter does not serve primarily the execution of the basic functionalities of the program code. It can be considered as an additional aspect.

Aspect-oriented programming (AOP) can be used to develop content-related issues in a developed program

be separated from each other, for example, the

Basic functionality of the program to be separated from the log outputs. Important basic terms in aspect-oriented programming are join points, point-cut and advice.

As a joinpoint is a possible starting point for a

Aspect designates. For example, in the Java programming language, this could be any catch block for which a log output should occur. Furthermore, joinpoints can also be variable accesses or method calls.

A pointcut is a set of join points where

due to predefined rules, the code is actually intervened. It's a kind of template used to search for joinpoints.

Advices are the actual,

additional code executed on a pointcut. This code can be executed before, after, or in place of joinpoints. The following is an example of the "weaving" of the

Metadata management described in a program flow.

The invention uses the principle of AOP for measured value processing with simplified metadata management. It assumes that there is code that processes values from measurements, but does not treat metadata.

Such program code may look, for example, as shown below in Listing 1: Start Listing 1

1 double m_l;

2 double m_2;

3 double m_3;

4 m_l = measure_l_pass ();

5 m_2 = measure_2_perform ();

6 m_3 = measure_3_perform ();

7 processed_measured value (m_l, m_2, m_3);

8 double process_measures (double mess_l, double mess_2, double mess_3) {

9 double result;

10 double buffers;

11 buffer = mess_l + mess_2;

12 result = buffer / mess_3;

13 return result; }

End Listing 1

In the illustrated program code, units or other metadata are not considered in any way. Of the

Developer of this special program code assumes that the readings of the function are provided in the correct units. When adding, the measured values must have the same unit of measure. The division of the measured values results in a new unit of measurement. These facts are not explicitly taken into account by the developer of this program code. The user of the illustrated Function in turn must know in what way in the

Function transformations of the units can take place.

In particular, he has to take care of correctly transferred values (mess_l, mess_2, mess_3). The resulting unit must also be known to him for a correct treatment of the measured values. Errors when transferring wrong units are not recognized or considered.

Using the example of the program code in Listing 1, the

Invention and the associated application of the AOP for transparent metadata management explained.

First of all, it is made known in the program code which variables are measured values that also contain metadata. In the example, this assignment or notice will be called by an additional call

Function performed in lines 4, 5 and 6.

For example, the following statements are inserted there:

4 m 1 = MetadataManager. setlnfo (measure 1) (),

String ("m"));

5 m 2 = MetadataManager. setlnfo (measure 2) (),

String ("m"));

6 m 3 = MetadataManager. setlnfo (measure _3_ perform (),

String ("s"));

The addition causes the variables m_l, m_2 and m_3 to be included in a central registry. At the same time, these variables are linked with the metadata, in the example these are the strings "m" and "s". They stand for the units of measurement meters and seconds in the recorded measured values. At this point, the values are no longer unitless, so operations on those variables always go through the processing logic for the attached metadata. For the application of metadata management are the

so-called joinpoints required. These joinpoints are all points in the program code where operations on the registered variables are performed. In the example, there are two join points in lines 11 and 12 when adding and dividing the measured values. At this point, the unit must be taken into account in the calculation.

The pointcut in the example is a set of two elements, the mentioned joinpoints in lines 11 and 12. If the variables m_l, m_2 or m_3 undergo further operations, the result would be more joinpoints, which would also increase the pointcut set.

Furthermore, there are advices for the treatment of

Program codes at the joinpoints. The Advices for the

Treatment of the measurement data in the example refer to all existing in the programming language Grundrechen-,

Comparison and bit operations. If such operations occur at the joinpoints, additions to the program code are made. These actually elementary operations are replaced by a function call into the processing logic. In such an external

Function, it is now possible to replace the elementary ones

Operation taking into account the metadata attached to the variable (s). In the case of addition, the actual operation is preceded by an examination. The metadata of the variables mess_l and mess_2 are compared. If both variables have the same metadata or units of measurement (here both "m"), then the addition can be done without further

Preprocessing be performed. Otherwise, in the external function either an automatic

Correction of a unit, for example, a conversion from "mm" to "m" or the generation of a warning or

Error message take place. Likewise, this division function can consist of calculating a new unit if it is allowed. The example would calculate the new unit "m / s." Alternatively, the processing logic may also generate a warning or error message if the division of the units in the scope of the program is not allowed.

• Weaving the advice at runtime:

A special feature of the invention is that Advices only shortly before the execution of the program code in the

Insert program code. This does not modify the original source code, but its compilation. For example, the compilation may be the Java bytecode in the Java programming language. When loading the bytecode of a class, the bytecode is thereby subjected to an analysis. All joinpoints of a pointcuts are searched for and by the

Advices added.

• - process for weaving metadata management:

The generalized procedure for "weaving in" the metadata management functionalities is shown in Figure 1. The gray marked areas are the components added by the invention.

The starting point is a usual process of software development, which has the program code 1 as a result. This program code 1 must be transparent

Slightly modified metadata management.

There must be an additional program code part 2 for the

Registering variables and metadata in the central registry 3 will be added. In the central

Registry 3 is then the variable with the associated metadata recorded. The program code is then compiled in the usual way and thus converted into executable bytecode (binary code) and, for example, in one Fixed storage of a processing unit stored. This is the compiled code 4 ready for later execution in the fixed memory.

Shortly before the actual execution of the bytecode or binary code 4, it is put into main memory

Processing unit loaded. Here begins the

Inventive modification of the code 4, the

transparent metadata management leads.

First, all joinpoints 8 in the compiled code 4 are identified. Joinpoints 8 result from all

Operations of variables in the central

Registry 3 were previously recorded. The result 5 of this first step of the method is the byte code (binary code) 4, with the points known as the join points 8. At these points 8 advices are inserted. They are either prefixed to the joinpoints 8 in the program sequence or adjusted. In another variant, the advices can also completely replace the join points 8 and the relevant code. The result of these process steps is a

Code 6 modified according to the invention, in which metadata is automatically carried. The software developer who created the original program code 1 will not be aware of the modification. He only has to make the first mentioned addition for the initial registration of selected variables and their metadata.

During execution, the advices or the processing logic 7 then access the central registry 3. From there, the metadata are fetched to selected variables to process them analogously to the originally implemented program code 1.

Elementary operations as joinpoints As joinpoints 8, all mathematical

Elementary operations that are applicable to metadata metrics. These are usually all basic arithmetic operations, comparison operations and

Bit operations.

• Mathematical functions as join points

In addition, special mathematical functions can be defined as join points 8. These are as

Function call before and are recognized as such and replaced. These are, for example, root function,

Logarithmic functions, trigonometric functions.

• metadata services

In addition to unit management, services based on metadata can also be transparently developed using the invention. Such a service is, for example, an error calculation during measured value processing.

Another service could detect if a value is that

Metadata management has just "left." This can

for example, an unmonitored function call (e.g., by calling a native function out of Java). After such a function call has taken place, can not be understood with certainty, what with the value

has happened. In this case, the variable becomes one

Added a metadata that marks this variable as potentially buggy. All results of the operations performed between this and other variables will also be considered potential by means of this service

marked with errors.

Other possible services are: - Calculating only with temporal conditions, for example, offsetting only from the oldest or the latest measured value or Measured values within certain time windows

Observing an orientation direction of measured values, for example, only measured values with the same

Orientation direction Calculated

Offsetting rights for access to data, so that certain data are only partially visible or statistically evaluable

• Enable / disable metadata management

Since advices are inserted at the join points 8 only shortly before the execution of the compiled program code 4, the metadata management can be switched on or off at runtime. As a result, for example, metadata management can only be activated for tests or for metadata-critical operations. This can leave the performance of the entire software system essentially unaffected.

Measuring devices are used, for example, for measuring speeds. These meters deliver as

Measurement data the information about the current distance covered since a certain time. For exact

Result calculation can be used on different sources for the distance measurement, z. B. GPS and vehicle tachometer. At the same time a time is in one

corresponding unit.

The interest rate must be from a

Merging the routes, from GPS and

Vehicle tachometer, to be calculated centrally. The speed must be calculated taking into account the units, otherwise a faulty speed will be calculated.

For the actual calculation becomes an algorithm formulated in programming language. This can initially be developed without regard to the correct units. At the point of algorithm development, the unit of measured values from the measuring devices need not be known yet. Subsequently, the measuring devices are connected to the algorithm for calculating the speed. This is done by means of a programming-language module in which the variables important for the speed calculation are identified as metadata-afflicted. It is in the

Program code made known depending on the meter type and accordingly output unit of measured variable that

Metadata must be considered and which it is. In the example, these are the measured quantities meter "m" and kilometers "km" for the measurement of the distance. In addition, the unit for the measurement of time and their

corresponding variable made known. The rest of the programming language formulated algorithm can

remain unchanged.

Subsequently, the invention of the underlying

Procedures over the identification of the Joinpoints up to the insertion of the Advices executed. The result is

modified bytecode required for execution under

Attention to the metadata is prepared.

The incoming measured values can thus be correctly processed and delivered with regard to the units

unit-related results, e.g. "M / s" or "km / h".

If the algorithm for processing the measured values

must be corrected, z. B. around him

To supplement averaging, only the

programming language formulated algorithm without regard to the units to be changed. After going through the process again, the new algorithm becomes the Correctly process output values and produce correct results in terms of units.

Method for data acquisition and processing taking into account metadata

List of Reference Program Code

additional program code part

central registry

compiled code

Result of the first step

modified code

processing logic

Joinpoints

Claims

claims

Method for data acquisition and processing in consideration of metadata, which

Additional information about the actual data

include in which a program instructions

including program code (1) before being executed in a processing unit into a compiled one

Code (4) is converted by

characterized in that in a first

Method step is set, which in the

Program variables (1) are associated with metadata that in a second process step, the locations in the compiled code (4) are determined on which operations are performed with the specified variables and that these bodies by means of a

Joinpoints (8) are characterized in that, in a third method step, by means of a function for processing the compiled code (4) (Advice) to the one provided by the join points (8).

marked positions of the code (4) in such a way

is modified that an execution of

Program instructions depending on the metadata is done.

2. The method according to claim 1, characterized

characterized in that the modification of the code (4) before, after or exactly at the by the

Joinpoint (8) marked point in the compiled code (4) takes place.

3. The method according to claim 1 or 2, characterized

characterized in that the modification of the code (4) by means of a jump instruction, a

Replacement of code parts or addition of code parts takes place.

4. The method according to any one of claims 1 to 3, characterized in that the modification of the code (4) during the term of the program can be switched on and off.