CN1914630A - Behavior based multi-agent systems as data types. - Google Patents

Abstract

The embodiments of the invention include a computer-readable medium having computer-executable components comprising at least one agent having at least one sensor component, having a goal or change method component, and at least one behavior component. The at least one sensor component generates at least one event based at least in part o n at least one generated value from the goal or change method component. At least one behavior component determines whether to activate a thread of execution based at least in part on the at least one generated event from the at least one sensor compon ent. The system complex execution threads can be generated by any operator on agents level, events level, sensors level and behaviors level.

Description

Multi-agent system as data type based on behavior

Technical field

The present invention relates generally to computer programming language, relates to the system and method for acting on behalf of computing system that is used to realize based on behavior or rather more.

Description of drawings

When considering in conjunction with the accompanying drawings, by coming, with the understanding more completely that obtains easily the embodiment of the invention, wherein with reference to following detailed description

Fig. 1 has illustrated according to the embodiment of the invention, the The general frame of RIDL agency's different piece.

Fig. 2 has illustrated according to the embodiment of the invention, accepts the form in invalid place in RIDL.

Embodiment

Embodiments of the invention comprise as equipment and the embodiment of data type realization based on the SOME METHODS of the multi-agent system of behavior.

With reference to the specific language enforcement that is called RIDL (intelligent robot definitional language) specific programming language notion is described at this.Yet should be appreciated that, under the premise of not departing from the present invention, can realize using other enforcement of different concepts described herein and aspect.

RIDL is the robot programing language who is applicable to hardware or software (virtual) robot program design, in one aspect in, it adds several key words on traditional language.For example, RIDL can be the superset of Java, as the AGENT# of the superset of C#, and DOTNET and C++, however should be understood that the other Languages structure that also can use except C#, DOTNET, C++ and Java.Therefore, RIDL described herein comprises the explanatory memorandum of the different concepts, principle and the method that drive the RIDL application class.

As describing herein, language, method and the enforcement of RIDL will be described with reference to a program compiler, yet, should be understood that the present invention is not limited to compiling, and the present invention also is not limited to special grammar described herein and enforcement.For example, each side of the present invention can read engine with interpretive routine or other Languages and realizes.

Compiler level aspect

Agency as data type

In different embodiment, the key word of interpolation becomes very simple by the establishment of multi-agent system.For example, add key word " agency " at the level identical with traditional " object ".For purpose herein, key word agency and interchangeable from the viewpoint of grammer to liking.The effect of key word represents that piece has defined the agency.Those skilled in the art will notice and can use other word that is different from " agency ".Possible in addition is to use and point out that this class object in fact is that the attribute of acting on behalf of comes this object of note.No matter adopt what grammer, its purpose all be point out packed be the agency and as move.

According to an aspect of the present invention, think that the agency is the native data types with the object all fours.All can also can be made the agency the action that object is made.The action of this class for example be new agency's establishment, agency elimination, will act on behalf of as the parameter transmission, be created to the agency quote (pointer), replication agent or the like.

As object, in fact Agent Definition has defined agency's classification.For example, an instance of agent is created by a new statement, perhaps creates in the new variables of that type of definition (acting on behalf of classification).

At last, can define a language, wherein, all objects all are by the definition agency, will not it may be noted that thus liking the agency.By determining whether to use following described feature (sensor and/or behavior), compiler can be distinguished positive representation (agency) and passive agency (object).Therefore, be merely able to by considering that following different characteristic understands the agency as data type fully.

Sensor

Sensor has defined the agency will be to its outside of working or internal signal.Sensor used herein is that note is the variable of the traditional type of sensor.By adding an attribute, or, can finish this note by pointing out to have defined particular variables with new key word to this variable.In an example, attribute " sensor " can be used for the existing variable of note.

Sensor is the part of multi-agent system.In one embodiment, sensor 104 is parts of particular agent, yet, also sensor can be defined as " overall situation ", wherein, it is not the part of any particular agent, but can be used for all agencies (thus it not can as agency " death ").

When sensor was updated or change, it caused an incident so that point out what has taken place.The incident that is associated with sensor has two: update event and change incident.Working sensor is as follows: all cause a update event when its receives new value.If should new value be different from previous value, then also cause a change incident.These incidents can be received (as described below) by behavior.

At this moment wait, language C# and C++ have had note, and it allows variable to come firing event when variable changes.Yet in order to receive this incident, the listener has to register on this initiation variable.By contrast, according to one aspect of the invention, the listener does not need registration to come the reception incident.For example, " behavior " 104 can be monitored the type of incident, and any incident that meets the type will be obtained by behavior 106.Therefore, the present invention and multi-agent system before form contrast, and wherein, it is dynamic acting on behalf of quantity and behavior need not be known which agency of existence.Under this class situation, behavior can not be registered on these agencies.When discussing any (any) operational symbol, will this function be discussed with further details.

Use a descriptive metaphor: suppose that you are carrying out telephone talk.In C# and C++, the user can with anyone talk that he was familiar with at the circuit other end.Yet on the scene if someone of the other end said that some and this user do not know that in advance other individual understands, this user will can not hear other individual.In RIDL, even if the user expects that other people has not been prenoticed other people there or this user and existed, the user also will hear speak at the other end everyone and can with they everyone talk.Therefore, the ambiguity in the environment has been considered in this aspect, and considers with the environment of acting on behalf of number and change of successive change.

Call the turn with C++ and relevant program design language at C#, a programmer needs to cause an incident clearly.The programmer must write code and call method about this incident, so that notify the listener (for example " throwEvent (myEvent) ").Yet in various aspects of the present invention, the listener can determine whether to write down an incident.

Behavior

Behavior is movable, and this means it and has its execution thread.From programmer's viewpoint behavior is concurrent running.When particular event occurred, behavior was not rreturn value but defines the action that some will be taked.What its definition should do in response to outside or internal event.Behavior always empty and cannot adopt any independent variable.They are by activating realization response intelligence in the combination of incident that clearly defines and Agent Status.

Though target and sensor are in the agency outside as seen, (private) that behavior is always privately owned or shielded.Have only shielded behavior can be disabled (overridden), and their observability (shielded or privately owned) must remain unchanged in all sub agents.

Behavior is the method that is noted as behavior (being the part of object or in the present invention, is the program of agency's a part).By adding attribute to method, or, can finish this note by representing to have defined ad hoc approach with new key word.Thereby, in an example, represent this class ad hoc approach with new key word " behavior ".

Behavior has their incident.For example, whenever behavior of beginning, it just causes an activation incident, as long as and finish, it just causes one and finishes incident.Can define other incident, and pointed incident title is only for purpose clearly herein, definite grammer may be different.The example of other potential incident is hang-up, births ﹠ deaths, wait or the like.Can realize the incident of any amount.In one aspect, incident can provide information about its state to other behavior and other agency.In one embodiment, behavior will cause these incidents and not need any action on developer's part.

In one embodiment, behavior may be different from traditional method on the mode that they activate.For example, call by some method for distinguishing as the classic method that in OO method, defines.Method may be potentially be called as the establishment part of a new execution thread, yet even in this case, what determine when to call this method is some external logic.By contrast, behavior can be controlled when they activate fully.In one embodiment, behavior can not be called and had only them oneself can determine when activate by external logic.Thereby these behaviors 106 do not need external code to activate.

Behavior can have points out the section that when its is activated.For example, this section can comprise a trigger condition.Although it is not must be like that, this trigger condition is separated with the code that will carry out in typical case.Yet in different embodiment, trigger condition is the part of the specification of behavior.

As mentioned above, notice trigger condition for behavior be local be important.The code that will carry out and cause those set of circumstances that its carries out at same place.This makes it possible to the behavior of the system in the inference isolation.When describing agency's action, can describe its behavior for the local perception in the world based on it, and need not know what causes these perception and by whom is caused.Only in response to the external cause around it, this for example, is the natural model that is used for economics, computer science, finance, commerce, social science and many other many large-scale problems in field to the agency.

In one embodiment, trigger condition uses the incident that is caused by sensor and behavior to promote its activation.Trigger condition comprises two parts conceptive: point out " time (the when) " part of the incident that it responds and based on being used to filter the value of this incident and " condition (if) " part of other parameter.Such as VisualBasic, the other Languages of C# and C++ and Java and so on allows to cause and catch single incident.Yet in RIDL, for example, may use eventful and complex conditions to come the selection behavior to wish that incident of catching.In essence, behavior is to the inquiry of some real-time forms of event application.

It is possible defining trigger condition based on known agency.Because the agency such as object is a data type, so the title of variable (if being stored in the variable) that can be by holding them, (pointer) quotes them perhaps by reference.Therefore, can define trigger condition statically.

Can be by waiting for that particular event characterizes different embodiment.At first, that mean need be in the agency appointment what want is which sensor or behavior.Next need to define the type that they are waiting for event.For example, natural model will be pointed out the agency that waiting for to connect a point, name sensor then, connect a point, name this incident then.For example " MyAgent.MySensor.updates " should be a natural model.Yet Any shape or form can be taked in this grammer.Key is to point out the agency, points out sensor/behavior then, finally points out incident.

In " time " of trigger condition part, can incident be coupled together with " perhaps (or) " key word or by thing with similar meaning.These permission people create them and want the tabulation of behavior to its responsive incident.

In " condition " part of trigger condition, can use the programming operational symbol of all routines that comprise boolean operator.In " condition " part, variable that all can use in the main body of behavior/method and operational symbol all are available.For example, can use each variable within the scope, wherein, this scope is as defining in the conventional language such as Java and C# and C++.

Target

Target is carried out the request that the agency is made.Target is not that movable object and it does not comprise data.As direct result, the incident that target is not associated with them.Target can be called and these parameters can be complex data types with a plurality of parameters.When they were called, they gave (passive) data member and member's sensor their data transfer.Therefore, can think that they are agency's interface or communication channel.Because object representation is to agency's request (agency can determine it is made or does not make a response), so they are different from conventional method (as on object).

As any other conventional method, target also has return type.Because sensor can only be provided with from the target the inside and can not be provided with from the conventional method the inside, so certain assurance that the method for thinking is a target to be carried out when asking is carried out, its possibility of result calls different to each.Do not guarantee to consider request, but depend on inference and agency's state, they may cause different agent actions.After all, the agency has important many work and will do, and for example keeps the robot of balance will never remove to note the tweedle that its sound transducer captures on the edge.

Target is the unique place that wherein allows to change sensor values.Because their expressions to request of agency, change so they change into sensor with their request, and agency's movable part can produce reaction to it.Can read agency's state with method, perhaps finish some thing directly, on one's own initiative.Target only has " spinoff (side-effect) ", and their generalities agency may be to the request to the agency of its reaction.Thereby target is only available on the agency, and unavailable on always passive object.If call method, then you know that also this agency will never ' know ' it.

On sentence structure, declare target in mode as conventional method.Yet they receive " target " determiner and are handling proxy requests to have pointed out the people.

Relation between the place that Fig. 1 has illustrated different RIDL agency 100 structures, incident that their cause and handled them.Target 102 has the write access to (among the only same agency) sensor 104, and sensor 104 changes or update event react new value by causing, and it is handled by behavior 106, and behavior 106 causes activation and finishes incident on their round.These incidents are finally caught by other behavior (not shown).All behaviors 106 are all managed to cause variation by the target of acting on behalf of among target 102 or other agency of calling them.

Any incident operational symbol

The clearly indication of the incident that we waited for is underactions all often.For example, when the developer wants to wait for a plurality of incidents.Solution will have the ground of omission and will not determine all possibilities, but will with combine such as other (other) operational symbol that defines below.This may be very tediously long (and sometimes even because shortage information and can not).Thereby, in one embodiment, the present invention includes the incident that is connected with.This idea is to wait for the agency's who comes from appointment sensor 104 or any incident of behavior 106.For example, a mode of writing this is the incident of omitting event name or title " incident " being used to be connected with.Alternatively, can conceive many other notes.For example, note " MyAgent.MySensor " or " MyAgent.MySensor.event " will make response to change and update event both.

Any sensor/behavior operational symbol

In a pattern, agency's structure is unknown fully, and does not know which behavior 106 or sensor 104 are within this agency.Still may be that someone wishes notified this agency's any behavior 106 or any activity in the sensor 104.Arrive this, in one embodiment, the expression of specific sensor 104 or behavior 106 replaced in the key word such as " sensor " and " behavior ".Once more, also can use other grammer, but the crucial clear and definite title that is to use counterfoil rather than sensor 104 or behavior 106.For example, the possible mode of writing this is " MyAgent.sensor.changes ".This agency will wait until always that any sensor of acting on behalf of among the MyAgent changes its value (it will ignore the renewal that does not change this value).Those skilled in the art will note that the developer has allocate event once more, perhaps use the selection that is connected with incident indication (as defining in the last paragraph).In identical tendency (vein), the agency can be with pointing out to wait for that the counterfoil of any behavior replaces the title of clear and definite behavior.For example, " MyAgent.behavior.activates " will mean that some just any behaviors in waiting agents MyAgent activate, and this will allow to monitor whether activity and need not know which behavior that defined of this agency effectively.

The ability of counterfoil that stays the title of sensor 104 and behavior 106 can allow to handle the agent application of undefined other agency when writing first agency.New structure is working properly in " time " of trigger condition part.Yet,, be likely that hope makes response to for example having any sensor that is higher than 100 value for " condition " part of condition.In a such example because stayed the counterfoil of the title of sensor 104, so " condition " part do not know it will on which sensor, test check it value whether above 100.Thereby " condition " part is needed to be which sensor 104 of knowing the agency has caused this incident.Therefore, in one embodiment, " time " clause can comprise the note of the sensor 104 of the title with variable.This variable will be stored quoting of the sensor 104 that caused this incident.Because after " time " part to the valuation of " condition " part, so " condition " partly can be used this variable to come mark sensor 104 and investigate its attribute (such as its value).

In the main body of the behavior 106 that activates by trigger condition, also can use the variable that comes from " time " part.Therefore, behavior 106 can cause sensor 104 to its response aiming incident as required.This combines with the attribute of examining oneself is powerful especially.

Any operational symbol of acting on behalf of

In another example, behavior 106 may be wished the incident that comes from any agency is made response, adds the agency who acts on behalf of group comprising the point of any time after the trigger condition that begins to wait for it in behavior 106.In fact, even behavior 106 is inactive and idle, and on developer's side without any code, behavior 106 also may like to know that each agency in this system, comprises the new entrant and leaves the agency of this system.

Those skilled in the art will notice that this problem fundamentally is different from previous problem.Definition agency when design acts on behalf of classification thus and cannot change its definition when operation.Therefore, when compiling, the agency always knows the tabulation of its factum 106 and sensor 104.Before, because do not have operational symbol, so what agency that always know that they talk about is in agency level.Therefore, if compile all agencies together, any operational symbol at incident, sensor and behavior level place can be found the solution by compiler (and because the agency is not used any operational symbol, always use known data type (agency) query interface or pointer thus, compiler is always known).

Introduced the new level of complicacy in " any " operational symbol at agency level place.If on agency level, use " any " operational symbol, the group of the unknown when then the agency can be added in compiling.This means that this agency must find the solution their any operational symbol when operation now.The group that allows RIDL agency adding come from other places becomes possible different aspect and discusses in the chapters and sections about " level aspect during operation " below.

In one embodiment, the agency can talk about the agency of initial the unknown.For example, in the trigger condition of behavior 106, can be with reference to acting on behalf of classification rather than the specific agency of reference.Aforesaid, the agency is data type and thereby has a title.The example of data type may be with or without title (variable is with respect to dynamic memory allocation).Therefore, by using the title (title of using in the Agent Definition) of proxy data type, can express agencies all in this classification.When a trigger condition was used agency's item name, in fact it meant it and wait for the particular event that comes from any agency who is other member of that proxy class.

Once more, though this for trigger condition notional " time " part effectively, it for " condition " part and also may bring problem for the execution of code.When the incident of acquisition, they may want the agency who detects this incident of transmission whether to meet specified conditions (" condition " part of trigger condition) then.Therefore, when they received incident, they also needed to catch quoting of this event agent of transmission.

In one embodiment, act on behalf of classification and can come note with variable name.For example, this variable will be stored the quoting of agency that is caused this incident.By this reference, can visit all public attributes of this agency, comprise the value of common sensor.Can finish quoting of these generations for all conventional actions that the agency quotes.

In another embodiment, can wish can be mutual with the agency of previous the unknown.For this purpose, in one embodiment, can be included to be used to be connected with the type agency quoting (pointer).For example, can define the agency with this reference type that is connected with.For example, will make response to any incident for calling of " Agent.sensor.event " from any sensor of any agency.Those skilled in the art will notice that different grammer notes is possible again.

Agency level incident and operational symbol

Up to now, all suppose to have only sensor 104 and the behavior 106 can firing event always.Yet in different embodiment, acting on behalf of them oneself also can firing event.Especially, represent that their produce, will wither away, will add group's (but generation elsewhere) or leave the incident of group (rather than extinction).This allow the agency more with mutual action be target make response.In one embodiment, " the welcome council " can make response to agency's adding, for example notifies their rules of this group.

The agency level incident can be associated with any operational symbol of acting on behalf of.For example, a possible note is "＜NewMember:〉MyAgentjoins ", its any agency who waits for classification MyAgent adds this group, and quoting of that new agency is assigned to variable NewMember.This is the example of a grammer, and can obtain identical effect by diverse note.Another example is "＜NewBorn:〉Agent.born ", it will make response to any agency of the new any kind of creating in group.Hereinafter Reference Services level aspect is discussed group in further detail.

Comprise (subsume)/recover (resume)

Often create intelligence system with layer, wherein, higher level and lower level are mutual and have precedence over lower level.However, lower level maintenance activity in typical case.Have only limited function to be disabled, and the great majority action is kept intact.Remove whole agency with it and replace it by another, the present invention would rather allow to comprise specific behavior.Comprise and mean a behavior and suspend another behavior, and take over control.Usually carry out the exception that this handles defined rule about behavior.After having handled exception, control is returned to the behavior that comprises by recovering statement.

Comprising and recovering is the feature in when operation.They can use in any behavior 106.For example, if a proxies store in variable " MyAgent ", then can directly be specified the behavior with title " MyBehavior " by " MyAgent.MyBehavior.subsume ".Again, identical effect can be realized in other grammer.

Behavior 106 can be comprised by any behavior, comprises it oneself.In one embodiment, involved behavior can recover (because it is inactive, therefore can't help it recovers itself) from any other behavior.Making the behavior 106 that comprises does not need identical with that behavior of making recovery.

In one embodiment, each behavior 106 all has (or certain equivalent title) the predefine attribute that is called " involved ".Though this attribute is the part of behavior 106, it is a sensor 104.For example, this sensor 104 can be scalar sensors (for example " int " or " integer (integer) ").In one embodiment, the involved number of times of statistics of attributes sensor.If behavior does not have involved, then its involved attribute will be zero.Whenever behavior receives when comprising request, counter will increase by 1.When behavior receives recovery request, it will reduce its counter.If involved attribute is zero, then the behavior will work.An involved behavior is finished when comprising.This means when recovering, and it just reevaluates its trigger condition.This means the behavior at it by the environment of at first checking it when activating again.This function can prevent the action of its execution error.

Those skilled in the art will notice that involved attribute is a real sensor.Therefore, when it changed, it caused an incident.Comprising state can use in trigger condition.Combine with (as described below) " completeWhen " statement, this also allows behavior 106 to monitor its state that comprises.Use this structure, behavior 106 is run time version before it is involved just, thereby guarantees not cause destruction owing to behavior is interrupted in the middle of its main body.

Because feature when above-mentioned feature is operation is so they can also be used for only having the agency who quotes.Therefore, can in the main body of the behavior of selecting other behavior with " any " operator, call these features.

Feature about comprising and recovering has been described as the grammer key word.Yet these features can also go up the available method of acquiescence as this agency and provide.For example,,, then be embodied as under the situation of the method on this agency, can write " shopAgent.subsume (" buyBehavior ") " in this function if want to comprise its " buyBehavior " for agency " shopAgent ".If comprising is a key word, then will write same along the row of " subsume shopAgent.buyBchavior ".Thereby, no matter be any ways of writing, notion remains unchanged.

Inherit

OO one of them key feature is an ability of creating derived type.The function of an object can be improved by inheriting all functions, and makes function invalid as required.Can similarly treat the agency with the present invention.When improvement is acted on behalf of, can carry out and the identical processing that object is done.Can make method invalid so that improve.

In one embodiment, because they oneself determine the time of activation, behavior can't be by other code call.Thereby behavior does not have parameter.When behavior was disabled, they were substituted by new behavior immediately.

Sensor is a kind of variable.Therefore, normal range application of rules.This means that sensor can replace sensor of the same name.

Most important, incident mechanism is kept intact when inheriting.As agency when inheriting a behavior, the trigger condition of this behavior will consider that it need check behavior in the sub agent.If there is not behavior to exist in the sub agent, then it will seek these behaviors in the parent reason.In conjunction with any sensor/behavior operational symbol, this allows the agency to carry out complicated comparatively speaking logic, and wherein, the parent reason can be known the structure of sub agent or its other performance clearly and function is provided.Fig. 2 has illustrated an embodiment, and wherein, it is invalid to accept in RIDL.

Any operational symbol of the agency who visits again

In the definition of agency's " any " operational symbol, can other title of specified class.If " any " classification is specified the item name with offspring, then " any " operational symbol will also be considered its all the progeny.Thereby agency's sub agent is the agency with improved same classification.

If use the title of sub agent in any operational symbol, then the parent reason will not be the part of this any operational symbol.The parent reason is not the part of the classification of sub agent.For example, if automobile is the sub agent of vehicle, any vehicle will comprise automobile, yet " any " automobile will not comprise each vehicle.

" any " operational symbol is that the fact of knowing succession makes them be applicable to the decision-making of making complexity.For example, the agency can activation behavior 106 on following condition: if any ship is close, and near do not have warship, then activate behavior.In another example, if teacher does not have the classroom and do not have available classroom, then this agency can activate behavior.Because sensor is variable and agency is data type, those skilled in the art will notice that sensor can self act on behalf of exactly.In addition, also can be used as parameter the agency is passed to method.

Subordinate act (event handling structure) division incident/change trigger condition

Top chapters and sections have been discussed the behavior with trigger condition.Also may create trigger condition is made response, and or cause particular event, the perhaps language construction of call method directly.Such structure has been divided trigger condition from method/behavior in one aspect in essence.Similarly, trigger condition can incorporation time and condition part.

The service level aspect

Become more and more difficult along with software is integrated, and software becomes and becomes increasingly complex, so the method for designing of software is also changing.Recently, existence is towards the tendency of service-oriented soft project.The essence of this trend is that software application has the interface based on the standard such as the service of XML World Wide Web.Software provides its function by this interface as service.It is the thing that service is combined purely that integrated different software package becomes.

In soft project, use name space that object set is become logical block together.For example, " disk " name space can comprise all programs with this disk interface.According to an aspect of the present invention, can be similar to object set mode together be gathered the agency with name space.Especially, the agency can be the part of name space, and can with object Sharename space.In other words, aspect this, because their boths follow identical rule, agency and object do not distinguished in language.

At the name space level, one embodiment of the present of invention comprise " service ".They with similar function come collection object and agency aspect, the service class at language hierarchy place is similar to name space.Especially, its set jointly realizes the agency and the object of single service.In different embodiment,,, or, can point out that name space is service by supposing that each name space that comprises the agency all is service by the attribute of this name space of use note by using new key word.

If name space is service, then it provides function.This function can visit by the interface of definition.In different embodiment, the invention provides the mode of specifying this interface.

In first embodiment, comprise that it is interface to this service that method defines object or agency clearly.For example, this can be by providing attribute to finish to this object or agency.

In another embodiment, comprise that method is come and this service name is as one man named this object or agency.In this case, public variable and method are the actual interfaces of this service.This service at first, with the automatically agency or the object of this classification of illustration, and each service can only be created an example of this agency or object.

Database layer time aspect towards the agency

A scheme towards the database of acting on behalf of (AODB) is the agency who each record (object among the OODB) is thought of as a Special Category.This agency includes only sensor (not having behavior), and forbids the succession on these agencies.Think each outside field, and field each calculating or that otherwise obtain all is a sensor.Therefore, database is the one group of agency who only has sensor.

This scheme monitors what has taken place the field to each record.In the time of newer field more, cause the incident (type that the trigger condition of behavior is used) that is updated.If the field change value then causes the change incident.The result can be defined as behavior supervision and response is made in the variation in the database.From notional viewpoint, database other agency abrim can be made the agency of response to it.

Alternatively, database broker may be like any common agency with sensor and behavior and other attribute.Difference between database broker and the common agency is that its sensor is stored in the database.In this case, software design teacher is conceptive deals with full-blown agency.The structure of database and the structure of agency plant must be mated fully.The advantage of this scheme is the degree of freedom completely that the designer has agent model.Compiler will be created and support the required form of this model.When using this scheme, desirablely come the note agency to represent that this agency is lasting with key word.This allows compiler to distinguish lasting and unabiding agency.

Level aspect---execute phase during operation

The optimization type that the ability of the case mechanism of describing aspect compiler can be finished by compiler illustrates.These are optimized influences run time behaviour.They are classified in when operation at this, but they need compiler to take action to generate essential tabulation and other material of engine when being used to move.

In different embodiment, it is the feature of RIDL that real-time optimization and speed-optimization are carried out.Aforesaid, trigger condition is split into " time " and " condition " part." time " part has been specified the incident of the valuation of " condition " part that triggers trigger condition.Because each incident all is linked to predefined behavior or sensor (and agency of definition more early), and because each behavior all relies on these incidents in its trigger condition, so can be with sensor as draw dependency graph between the behavior of the permission in the chart.Whenever upgrading or changing sensor, perhaps activate or consummatory behavior, this event propagation is by this chart and the sign of the trigger condition of valuation once more is set.If trigger condition valuation and they are satisfied, sign then are set point out to need to carry out the behavior.

In one embodiment, there are the behavior of selecting the process sign and the set of carrying out its execution thread.For example, be single thread on the set of execution thread is may one extreme, perhaps another on extreme is and the as many thread of behavior.The quantity of execution thread can depend on the compiler execution, but may separate with the quantity of agency in the system and behavior.Those skilled in the art will notice and can adopt many forms to come " sign " behavior.For example, it can comprise the variable that is set to indicate, the execution thread that behavior (sign) can be added to tabulation and/or be exclusively used in the behavior can begin (this be equivalent to indicate simultaneously and begin carry out).

Automatic priority for behavior detects

According to an aspect of the present invention, give behavior lower in hierarchy chart with higher priority.In fact, lowly in level mean that the behavior is near hardware or software interface.That means their relatively near incident, and may to require them be to react more rapidly.

Example in robot and the machine control is very clear by this.If behavior is directly coupled to hardware sensor, then need very fast response probably.Yet in highest level, behavior is to making response by other RIDL sensor being made the sensor that the behavior of response sets up.In other words, in the chart higher behavior with more abstract data work.Handle these information usually than low level behavior time-sensitive (for example, " reflection " is than " thought ") still less.

As previously mentioned, the incident of sensor 104 or behavior 106 will be propagated by dependency graph, and will need the trigger condition of valuation again to be placed in the tabulation.In one embodiment, the trigger condition processor will be handled this tabulation.For example, this tabulation can be based on priority, this means when adding the trigger condition of new behavior to this tabulation, can be ordered into it and carry out in the formation, thereby in case it has all limit priorities of waiting for behaviors just is performed.Priority is reflected to the distance of permission, and wherein, permission has limit priority, and each additional dependence reduces priority.

In less system, might carry out valuation immediately to trigger condition.In this case, because the valuation of supposition trigger condition is immediately, do not have other behavior to wait for, each behavior automatically has limit priority.

If satisfy trigger condition, then Dui Ying behavior just is stored in the new tabulation that comprises the behavior that will carry out.Again, this tabulation can be sorted by the priority (using as above-mentioned same priority definition) of the behavior.Then, the set of thread can be carried out the wait behavior with limit priority.

End product is that the behavior of lower level can be carried out repeatedly before the behavior of the higher level of the behavior of depending on lower level obtains carrying out chance.The behavior that this means higher level may be omitted " frame ", and wherein, frame definition will be real trigger condition for the supposition assessment.This feature has guaranteed that at it may be useful in the rapid response at the minimum level place that needs respond rapidly.Simultaneously, it with have material uncertain principle to be complementary to agent actions.The agency can not guarantee forever its believe for really in fact (still) for very.Thereby the supposition that requires the agency whether to continue to detect it still keeps.Because it is irregular to handle upwards to construct multi-agent system from bottom, the end product multi-agent system robust of this uncertain principle is many.

A plurality of incidents are always waited in behavior 106.In this case, behavior 106 will always have a priority that is lower than the incident that just causes its execution.Therefore, the priority of behavior dynamically changes when operation.

The incident of sensor 104 has the priority that is lower than the renewal sensor and causes the behavior 106 of this incident.Outside in subordinate act 106 is upgraded under the situation of sensor 104, will think that it is the permission incident with limit priority.

The behavior 106 that triggers on the system definition incident such as timer will be considered to the permission behavior and will have limit priority.

In other different embodiment, existence need be in all behaviors effectively and the ancillary rules of the influence priority of distributing.For example, the behavior 106 that is activated based on finishing of another behavior may always have the priority that is lower than other behavior.In another example, based on the activation of another behavior and the behavior that is activated may have the priority identical with that another behavior.

Detailed behavior

In different examples, it not is the priority of intention that above-mentioned stratification scheme may produce.Especially, may exist two to rely on chart in the inside of software.For example, one of them chart may be responsible for carrying out data.Another chart may monitor the action of another chart.Because this class chart may be from identical sensor, and can not reciprocation at higher level, so compiler can not distribute higher priority to a chart or another chart.Alternatively, compiler can distribute similar priority to both, thereby allows them fight for resource in working time.

A solution of this problem is to allow the user come the priority of clear and definite define behavior.Yet this scheme may be easy to generate error.Therefore, different embodiments of the invention comprise " detailed " designator.For example, when behavior was labeled as " detailed ", this may mean and not allow the behavior to omit any frame.For example, the behavior will respond with sufficient priority, so as to guarantee it next time its trigger condition become and be performed before true.In different embodiment, exhaustivity can not guarantee that behavior is performed in the special time frame, yet it can guarantee that it just is performed whenever trigger condition becomes genuine the time, and next execution takes place after will be before one complete.

And a detailed behavior can be detailed with respect to its incident.Thereby its exhaustivity may be to relying on the not influence of other behavior in the tabulation.In other words, not because a behavior is detailed, another behavior that its is waited for also becomes detailed or changes to some extent in priority in another way.Thereby, have only to be labeled as detailed behavior clearly and just certainly never to omit any frame.Certainly, if another behavior only depends on detailed behavior, because generated many incidents of its wait, it can be triggered more continually than normal behaviour.

Redundant behavior

Redundant behavior is opposite with detailed behavior.When behavior was labeled as redundancy, this meant it and has the priority all lower than all conventional behaviors.As detailed behavior, redundant behavior changes the priority of other behavior never in any form.For example, have only the behavior that clearly is labeled as redundant behavior just can have this lower priority.Certainly, if another behavior only depends on redundant behavior, because do not generate the incident that it is being waited for, it will never be triggered more continually than this redundancy behavior.

The level chart of real-time mapping

Under the support of real-time system, allow clearly behavior to be mapped to specific numerical priority level.For example, the developer can fix these behaviors, and for each behavior that does not define the numerical priority level, rule defined above can be used.

The continueWhen statement

" continueWhen " statement is the statement that trigger condition is followed in the back.It is the statement that can a bit use arbitrarily in the behavior main body.For example, it can indication action wait until always the trigger condition result of appointment be true till.Such statement is useful especially when behavior needs the action sequence of execution sequence.It can also provide basic structure guarantee between the behavior synchronously.Sample situation is when robot need lift arm and reaches certain height (sensor) (action).Then, after it succeeded in doing like that, it may need by next button.

The continueWhen statement is the contracted notation for the function that can also the user mode machine realizes.For example, the behavior that comprises the continueWhen statement can be split into several behaviors, these several behaviors reach identical effect in conjunction with the trigger condition of appointment with state machine.In one embodiment, state machine is in its state 0 and at first with the trigger condition waiting status 0 of behavior.When the first of behavior finished, it placed state 1 with state machine.The trigger condition waiting status 1 of second behavior appointment in continueWhen of the part after the imitation continueWhen.When behavior last in the state of activation machine, state put get back to 0.

In one aspect, compiler can only be applied to software to this transformation, for example passes through shown in the code:

　　void MyBchaviorQ：behavior<!-- SIPO <DP n="16"> --><dp n="d16"/>　　when TrigCondWhen　　ifTrigCondlf　　{　　  Statement1；　　  Statement2；　　  continueWhen TrigCondContinueWhen1　　         if TrigCondContinue1f1；　　  Statement3；　　  continueWhen TrigCondContinueWhen2　　         if TrigCondContinueTf2；　　  Statement4；　　  }

This can change into:

　　int MyB ehaviorState＝0；　　void MyBehaviorPart0()：behavior　　when MyBehaviorState.changes or TrigCondWhen　　if(MyBehaviorState＝0)and TrigCondIf　　{　　  Statement1；　　  Statement2；　　  MyBehaviorState＝1；　　}　　void MyBehaviorPart1()：behavior　　when MyBehaviorState.changes or TrigCondContinueWhen1　　if(MyBehaviorState＝1)and TrigCondContinueIf1　　{<!-- SIPO <DP n="17"> --><dp n="d17"/>　　  Statement3；　　  MyBehaviorState＝2；　　}　　void MyBehaviorPart2()：behavior　　when MyBehaviorState.changes or TrigCondContinueWhen2　　if(MyBehaviorState＝2)and TrigCondContinueIf2　　{　　  Statement4；　　  MyBehaviorState＝0；　　}

The result is the method that comprises trigger condition the behavior and carry out its terminal point.

In one embodiment, compiler can be transformed into a plurality of behaviors to the continueWhen behavior, and can guarantee that variable is (because they conceptive be local) that can visit from two behaviors (rather than from other places).For example, it can be created in the agency by unique title that does not quote in any other place that is used among the agency be the overall situation variable realize this.

The completeWhen statement

In the above-described embodiment, in the main body of behavior, use the continueWhen statement.Yet when and completeWhen statement all use in the outside of the main body of behavior.When thereby " when " condition is pointed out executive agent." completeWhen " statement is the contrary of " when " statement.Its appointment behavior should stop the trigger condition to carry out thereon.CompleteWhen can follow main body once more.In one embodiment, when triggering completeWhen, stop the main body of behavior and carry out completeWhen main body afterwards.In the main body of completeWhen, can visit all local variables that in the main body of behavior, define.Conceptive, this code is waited until whole codes of execution in body interior and replacement.

Complete When statement can be realized by the main body of conversion behavior.For example, suppose following behavior:

　　void MyBehavior()：behavior　　when TrigCondWhen<!-- SIPO <DP n="18"> --><dp n="d18"/>　　ifTrigCondIf　　{　　  Statement1；　　  Statement2；　　  Statement3；　　}　　completeWhen TrigCondCompleteWhen　　ifTrigCondCompleteIf　　{　　  CStatement1；　　  CStatement2；　　}

This can convert the following code with same effect to:

bool MyBehaviorCompleteNow＝false；　　void MyBehaviorMustComplete()：exhaustive behavior//& highest priority　　when TrigCondCompleteWhen　　ifTrigCondCompletelf　　{　　       MyBehaviorCompleteNow＝true；　　}　　void MyBehavior()：behavior　　when TrigCondWhen　　ifTrigCondlf　　{　　     if not MyBehaviorMustComplete<!-- SIPO <DP n="19"> --><dp n="d19"/>　　  {　　  Statement1；　　  if not MyBehavio rMustComplete　　          {　　          Statement2；　　          if not MyBehaviorMustComplete　　                  {　　                  Statement3；　　                  }　　              }　　    }　　    if MyBehaviorMustComplete　　    {　　        CStatement1；　　        CStatement2；　　}　　    }

In different embodiment, because no matter how high the priority of the behavior have, the fact that it must be finished all has even higher priority, therefore must have limit priority to the inspection of finishing condition.In one embodiment, because anything of trigger event do not upgraded in the inspection of finishing condition, can use detailed key word in this case.For example, its more new variables rather than sensor.Thereby compiler can convert first code to the latter, thereby and realizes this function.Alternatively, also can adopt other method to realize desired function.

No matter select what method, compiler can convert the behavior with completeWhen statement to the behavior with this quasi-sentence.Thereby, it only be one of great use and powerful contracted notation.The use of statement is extremely frequent, particularly in conjunction with the sensor that comprises of the system definition of each behavior, shown in next example:

void MyBehavior()：behavior　　when OtherSensorl.changes　　{　　    Statement1；　　    Statement2；    }　　completeWhen MyBehavior.subsumedchanges　　ifMyBehavior.subsumed　　{　　    Clean_up_behavior；　　}

In fact, the use of this statement is so frequent, to such an extent as to allow to use a plurality of completeWhen statements at the end end of a behavior, catches different incidents and takes different actions.For example, if wish a plurality of incidents are taked identical action, then can allow trigger condition meticulousr.

After conversion, in one embodiment, compiler can generate the code that a plurality of completeWhen statements carried out in the service condition statement.In having the example of nested condition statement:

void MyBehaviorO：behavior　　when TrigCondWhen　　ifTrigCondIf　　{　　  Statement1；　　  Statement2；　　  Statement3；　　}　　completeWhen TrigCondCompletcWhen1　　ifTrigCondCompletelf1　　{　　  C1Statement1；<!-- SIPO <DP n="21"> --><dp n="d21"/>　　  C1Statement2；　　}  complete When TrigCondCompleteWhen2  ifTrigCondCompletelf1  {    C2Statement1；    C2Statement2；  }

This can convert the following code with same effect to:

int MyBehaviorCompleteNow＝0；    void MyBehaviorMustCompletel()：exhaustive behavior(& highest priority)    when TrigCondCompleteWhen1    ifTrigCondCompletelf1    {         MyBehaviorCompleteNow＝1；    }　　void MyBehaviorMustCompletel()：exhaustive behavior(& highest priority)　　when TrigCondCompleteWhen2　　ifTrigCondCompleteIf2　　{　　    MyBehaviorCompleteNow＝2；　　}　　voidMyBchavior()：behavior　　when TrigCondWhen　　ifTrigCondIf　　{　　  if not MyBehaviorMustComplete<!-- SIPO <DP n="22"> --><dp n="d22"/>　　  {　　  Statement1；　　  if not MyBehaviorMustComplete　　        {　　        Statement2；　　        if not MyBehaviorMustComplete　　        {　　              Statement3；　　        }　　  }　　}　　if MyBehaviorMustComplete＝1　　{　　      C1Statement1；　　      C1Statement2；　　}　　if MyBehaviorMustComplete＝2　　{　　     C2Statement1；　　     C2Statement2；　　}　　  }

Once more, by firing event rather than use nested condition statement, can obtain similar effects.Compiler also can be operated and check more intelligently so that reduce the test quantity that needs execution.

Those skilled in the art will notice and comprise also and can similarly work.By using " condition " statement,, stop the method that comprises immediately and in fact do not kill this thread (latter causes more overhead processing and bigger complicacy) perhaps by firing event.Above-mentioned conversion illustrates, on when regarding to the operation that the behavior that do not have continueWhen and completeWhen statement discusses level carry out, also can be applied to behavior with these statements.

Deadlock Detection

Level aspect during operation---agency's movability

Group

Top explanation concentrates on the agency who all knows mutually.Yet in one embodiment of the invention, the agency only knows the agency who is present in its " group ".For example, group may be identical with application program.Thereby all agencies in the application program can know mutually.Those skilled in the art will notice that it is a plurality of application programs that the application program that usually will comprise a plurality of groups usually is considered to.

In one embodiment, group self can move.That is, service can be oneself copying to another computing machine, and can remotely start it oneself.Therefore, this group can allow it own movable on another computing machine.And in a such embodiment, the agency can move between the group of duplicating.Especially, the agency can generate the message that sends to another group, and this message comprises its state.For example, this class message can comprise this agency's the type and the value of its all the sensors.An enforcement can be that the sensor " dehydration " that will act on behalf of becomes XML, and this XML definition is sent to the group of duplicating.There, can create new agency, and sensor that can this agency is all is arranged to the value (" make and become hydrate again ") that receives in the XML message.Then, this new agency can be confirming to send to first agency after message, and first agency can select to destroy oneself then.Alternatively, if this agency does not destroy it oneself, then it has duplicated it oneself simply.

In one embodiment, when in group, creating when acting on behalf of (on movable new operational symbol) at any time and for any reason is new, will all carry out valuation to the trigger condition of all behaviors so for example also by data type.Depend on the result, will activate or not activate the behavior.Therefore, quite possible is that the behavior of moving to new attribute that activates and produce its agency in group because its trigger condition does not also satisfy in new attribute, can not activate in new attribute immediately.

Grid computing

The ability that group's (on other processor and machine) produces their copy can allow them to utilize all available in network processing poweies through authorizing.Thereby many agencies of grid computing explain and can produce.For example, through licensing all near computing machines can be automatically and dynamically create the computing grid of carrying out multi-agent system.Therefore, for the application program such as recreation, physical computing, the calculating of extensive bank and other application program that scales up, multi-agent system can be grown up and be surpassed the ability of single computing machine.

Migration between similar group

If all agencies' definition all is same, then group structurally is same, and group does not have the additional agent relevant with another.The signature of sensor is the title of this sensor and its type.Thereby, if act on behalf of all the sensors that A has identical title and act on behalf of A have have with act on behalf of B in the sensor of identical signature, think that then acting on behalf of category-A is similar to and acts on behalf of B.And if a part of proxy class of the C1 of group is similar to the agency among the C2, then the C1 of group is similar to the C2 of group.Yet, be not that all agencies of C1 need to be similar to agency among the C2.

In one embodiment, the agency can similarly move between the group.Especially, the agency can generate the message that sends to another group, and this message comprises its state.For example, its state can comprise Proxy Name, and for each sensor of this agency, the signature of this sensor and value thereof.Can be with this information combination (for example, XML definition in) and send to another group in packet with duplicate requests.In the group that receives, check the title of agency's appointment.Carry out inspection and determine whether this agency is similar.If this agency is not similarly, then the message of that meaning is sent and is not taked back to further action.If this agency is similarly, then positive acknowledgment is sent it back and send group and the new instance of agent of establishment in receiving group.To all distribute to this agency for all reception values of sensor.Agency's establishment, and the renewal of sensor will send a large amount of incidents by the group that receives.

How the agency begins migration

Each group all is service or has interface.For example, interface can receive the message such as ACL (agent communication language) message or XML message.In one embodiment, RIDL utilizes the service of XML World Wide Web to set up communication between group.Each group all has the unique ID that is represented by URL usually.

The agency who wishes migration must know that it will move to the ID of group there.In one embodiment, two special functions are predefined methods of each agency: " int copyToCommunity (ID) ", wherein, above-mentioned request duplicated data packet is sent to the group with assigned I D, and the return code of this function comprises successfully indication (0=duplicates successfully); " int migrateToCommunity (ID) " wherein, at first carries out copyToCommunity, and needs only successfully, just eliminates the agency who is replicated.If it is own for agency migration, then may be that it is not carried out after the migration instruction that and goes.If migration is success not, will carry out next line, allow the agency to diagnose based on rreturn value.Again, the grammer of enforcement can change.

In one embodiment, the developer need only know the ID of similar group, and need not know communication protocol, World Wide Web service, ACL or any other technology.Thereby when establishment was acted on behalf of, it just had the ability of duplicating and moving between similar group, and need not the developer make any work.In one embodiment, this function is included in the method all available on each agency.Alternatively, this function can be provided by the storehouse that comprises function " int copyToCommunity (AgentType, ID) " and " intmigrateToCommuniry (AgentType, ID) ".

Thereby migration is inherent for language, perhaps acts on behalf of in the predefined method at each, perhaps in the routine library of issuing together with language.By changing the mode that group begins, the developer can quite easily create " mainly " and " less important " group with identical source code, wherein, the agency of oneself creates in main group in certain bootstraps (bootstrap), and less important group is similar to main group, but they do not comprise on the remote terminal of acting on behalf of and being installed on the network, wait for receiving the agency who duplicates or move to their theres.In one embodiment, by analyzing the structure symbol and removing any statement of creating initial agency, any main group automatically can be converted into less important group.In an application program example, the engine when game developer can provide an operation, its PC that can be installed in LAN (Local Area Network) goes up and need not write extra-code so that utilize the ability of those PC.

Searching has similar agency's group

In one embodiment, by using already present foundation structure in the definition of ACL and the service of XML World Wide Web, the agency can obtain the ID that it wishes to move to the group there.In addition, the agency can seek all available groups on computing machine or the network or comprise similar agency's group.Generally speaking, suppose and act on behalf of when having group there under the interested situation that it knows the agency's of its hope dialogue type.For example, can provide inquiry to seek all entities that comprises the authorized agency nearby.The agency of appointment may be agency itself or another agency.Searching can be for similar agency and for structurally same agency.Alternatively, the example that can provide inquiry to define the agency of how many authorized agency's signatures is present in the group.

In one embodiment, may wish to allow the designer to use this class function and the unnecessary agreement of knowing its back.For example, each agency can comprise the predefine method of following form:

communityCollection?findCommunities(StructuralIdentical：bool＝false)

Wherein, the communityCollection type is the set of communityCollectionItem, and communityCollectionItem is the structure with two parts: the quantity of set ID and the agency's that existed example.Parameter " StructuralIndentical " can be pointed out to seek agency (very) identical on the structure or seek similarly agency's (vacation), and wherein, default value is to seek similarly agency.Once more, this function also can be with language issue the part in storehouse, wherein, function as follows is available: communityCollection findCommunities (AgentType:agent; StructuralIdentical:bool=false)

Those skilled in the art will notice by changing grammer with many modes can obtain identical function.

Stride the agency of group work

In one embodiment, the agency can automatically be moved to the agency with less particular type or be had the more group of multiresidue CPU ability.Yet " any " operational symbol depends on group, and can not choose the agency in other group.For example, in multi-user's video-game, the user has 1,000 soldier's army, and each soldier represents by having the complicated fight and the agency of psychology behavior.And another more powerful relatively computing machine is the part of local networks.If this user can use that machine in recreation, then computing power can be used for huger army and this user will have bigger ability in recreation.Thereby less important group can be used for receiving additional soldier.Yet, in less important group and by the soldier that any operational symbol is made response to their environment, no longer can see other agency in the main group.

Top different embodiment provide solution to this problem.Whole model promotes by the incident that is produced by sensor and behavior.Agency's state mainly is stored in the value of sensor.In order to allow agency's response mutually between group, need keep sensor with counterfoil.Thereby, may wish keeping which agency of decision can be moved out to other machine which cannot simultaneously freely, allow these counterfoils automatically create by system.

In order to reach this target, can will act on behalf of note with key word or attribute and be " autoMigrate ".For example:

void?MyBchavior()：autoMigrate?behavior

In one embodiment, for all autoMigrate behaviors, but compiler can also comprise all the sensors not have to create in the main group of behavior second " counterfoil " agency.As described below, this counterfoil agency will be responsible for transmitting sensor after a while.In less important group, autoMigrate agency's definition fully, and each agency's of autoMigrate agency dependence counterfoil agency will be available.

When the autoMigrate agency was activated, it was worked as common agency and can monitor " the carrying out tabulation " that is used for this agency.In one embodiment, described in the chapters and sections that detect as superincumbent automatic priority, carrying out tabulation and being needs to carry out and according to the tabulation of the behavior of prioritization.

For example, ' X ' is longer for ratio if behavior tabulation becomes, and then can select the autoMigrate agency to be used for migration, and wherein, ' X ' is the parameter that can be disposed by the designer.Therefore, use event model and the measurement of the priority detection that obtains as the processor activity, wherein, as long as there are enough processing poweies, the autoMigrate agency just can stop on computers.

AutoMigrate agency in order to select to be used to move can use several standards.For example, can select to rely on the autoMigrate agency of the external sensor of minimum number.The autoMigrate agency's that in this case, can select to be used to move order can be determined in compilation time.Another system of selection can be to use the autoMigrate agency who is activated the most continually, to reduce the working load of resident computing machine.Another method can be selected at the autoMigrate agency who carries out the behavior that has maximum quantity in the tabulation, perhaps selects at random autoMigrate agency or another method.

In one embodiment, in main group, when upgrading sensor among the agency who relies on the autoMigrate agency, will upgrade just sending to less important group for the value of this sensor, it upgrades the counterfoil that is used for this agency there.Equally, in less important group, when upgrading the agency's who moves sensor, just the correlation with this sensor sends it back main agency, and there, its upgrades the agency's who is used to move counterfoil.Because we will upgrade sensor, so this will reproduce the incident that exists in the less important group.It seems that from the viewpoint of using the agency compiler will guarantee that the incident of being created by counterfoil is consistent with the incident of being created by initial agency.

In one embodiment, the information transmission between the group can be wrapped with XML and be finished.For example, can add-on system the behavior of definition, its incident to this agency is made response, and can act on behalf of transmission information to the counterfoil in other group.The agency can or send the title of counterfoil to (having known ID's) other group, perhaps directly sends unique ID (pointer) to the sensor of this counterfoil.

At design time, can specify classification is autoMigrating.Yet, migration be independent example.Thereby each agency determines oneself the time of its migration.Therefore, some examples of autoMigrate agency can move, and same other example of acting on behalf of classification can not move.

In one embodiment, for single main group, may there be a plurality of less important groups.When each migration, can top have the method for describing in similar agency's the chapters and sections about searching and select group with being similar to, yet in this case, standard will be to seek the group with structurally identical agency.

Migration agency's safety issue

In one embodiment, the security level (or ACL level) in the service of XML World Wide Web has solved safety issue.For example, the safety practice of using about service should prevent to act on behalf of the group of moving to them and not having mandate.

Debugging level aspect

The debugging behavior

Multi-agent system is to be difficult to debugging, because they have too many parallel behavior.Mistake during operation may since the common generation of race condition and extremely difficult incident of reproducing produce.Because spinoff makes the reproducing not exclusively of concurrent characteristic of system, and is almost nonsensical by " step by step " of code.Traditional adjustment method lost efficacy in the debugging between the agency.Therefore, act on behalf of the deviser and should guarantee that the agency is for external error robust as far as possible.

Thereby, by coming inference, can utilize the feature of listing above for deviser's interests according to agency, behavior and trigger condition rather than according to for example method and order generation, sign indicating number.

In one embodiment, key word or attribute can point out that a behavior is " debugging " behavior, such as:

void?MyBehavior()：debug?behavior

when?TrigCondWhen

ifTrigCondIf

{

//statements

}

In a such embodiment, the processing debugging line is with can being different from common behavior.For example, can only compiling debugging behavior in " debugging " pattern.In " release " pattern, can automatically remove these behaviors.In another example, the debugging behavior can have limit priority.In one embodiment, it is that the interior statement of main body minimizes that the deviser can make debugging line, and wherein, this class behavior has empty main body, therefore has only the triggering of the behavior to be monitored.In another example, the debugging behavior can not have continueWhen or completeWhen statement and can be not involved or recover.Generally speaking, the debugging behavior can not participate in the activity of agency plant.It will only observe (and writing down sometimes) activity.

In another example, in debugging mode, each behavior can comprise the logic that system " is freezed ".Freeze to stop all behaviors so that allow to analyze " snapshot (snapshot) " of dynamic system.In another example, the debugging behavior can be in " zero execution time " operation, and wherein, when a debugging behavior was activated, it freezed system, and then all maintenances executive agent when freezing.System thaws when the debugging behavior is finished.This allows rolling inspection on the particular point of debugging behavior in working time, and/or upgrades daily record thus.

Handle exception

Exception is included in the illegal operation of carrying out working time.The action of this class comprise null pointer use, removed and many other problems by zero.These problems may take place in trigger condition valuation and executive agent.

In traditional language, cause terminal captive error event in behavior.If this incident is not hunted down, then this incident is outwards propagated, and may collapse up to final total system.According to the present invention, in one embodiment, a predefined scalar attribute " exception " can be associated with behavior.As involved attribute, the exception attribute is a genuine sensor.When it changed, it was with firing event.For example, the deviser can use the completeWhen statement to come to catch when exception takes place and handle them.In one embodiment, if its exception is not handled in behavior, then the behavior finishes immediately.Thereby this exception is not propagated and system works on.

Because exception can be genuine sensor, so any other behavior may be made response to it among this agency.Therefore, another behavior among this agency can be exclusively used in and handle the exception that takes place among this agency.

The matrix analysis device

In one embodiment, " matrix analysis device " can monitor them when the agency is carrying out.For example, as the analyzer in the electronic equipment, it can constantly illustrate the value of all correlation parameters and show data with the different forms of checking.

For example, a group of checking to find on the computing machine that may be illustrated in the debugging mode (otherwise the matrix analysis device can not be seen them).Another is checked the single agency with its all sensor and behavior can be shown.For example, for each sensor, a value can be shown.For behavior, code status can illustrate with color, and for example: black can mean the current inertia of this code; Green can mean this code and carry out; Orange this code that can mean is waiting pending; And redness can mean this code the term of execution mistake appears.

Another checks and can be shown single or point to each proxy table, and wherein, color can be pointed out this agency's state, for example: if any a part of code of this agency the term of execution mistake appears, then this agency may be red; If this agency is not red and any behavior is waiting pendingly, then this agency may be orange; If this agency is not red or orange, and any behavior is movable, and then this agency may be green; And for the condition of " any above non-", this agency can be a black.In one embodiment, this can be checked and be expressed as matrix.For example, the screen of 1600 * 1200 pixels can illustrate maximum 1,920,000 agencies' activity.And, can give prominence to specific pixel and select the secondary view to allow for specific agency, for example, can be used for analyzing in more detail.

IDE level aspect

Act on behalf of view

In another embodiment, can define vision acts on behalf of the deviser and comes visually monitoring agent.Thereby, in such visual modeling person, may there be a large amount of views.For example, in a view, the developer can see this agency with the mode that is similar to UML.Be alternative in variable or method single designator before in OO (OO) modeling, can there be two designators, wherein, first designator is identical with OO's, to point out whether method, behavior, variable or sensor are privately owned, public or friendly (friend), and second designator illustrates it is method or behavior, and it is variable or sensor.Second designator points out that in essence it is broker concept (sensor or behavior) or object notion (variable or method).

The behavior view

In the behavior view, illustrate outside sensor and the behavior agency under them.They come note by agency's title, but same agency's sensor and behavior do not need to be illustrated in identical near.In fact, behavior and sensor are expanded away according to dependence, permission sensor and behavior are presented at bottom (perhaps on the top or from left to right or from right to left, this is all according to user's preference).In one embodiment, sensor and behavior link together with the dependent arrow that shows between those.

The dependence view

Based on the notion of RIDL, can define the dependence chart.In one embodiment, this chart can show in selectable mode.For example, the agency can be shown to the user's (as acting on behalf of view) and the arrow that can between the agency, draw so that dependence (those skilled in the art will notice that definite priority may change and can not illustrate statically in working time) to be shown.Alternatively, the agency can be shown in the behavior view, and can draw arrow once more so that dependence to be shown between behavior and sensor.

Group's view

In another embodiment, be similar to top debugging level aspect, group's view can illustrate the agency in working time.

Study agency: neugent---aspect

In artificial neural network (ANN), neuron is a mathematical formulae.They provide the quantity of the trigger value of representing them.Often only create as 0 or 1 of trigger value with threshold value.Formula in the neuron wherein, all multiply by special-purpose multiplication value with each node based on the value of calculating as all node sums at lower level place usually.Under the situation of discrete ANN, weights must be between 0 and 1.By changing independent weights, and by neuron is placed on the layer, processing complex data (such as the object on the recognition image) can learn by instruction by system.

In RIDL, can use to slight modification the notion of neural network.In one embodiment, neuron is represented by the agency.Its trigger value is that sensor and it have the incident that comes from the trigger value in the lower level is made the behavior of response to recomputate its trigger value.End product is to use notion, the RIDL software of ANN can learn very complicated task and need not programme to answer (thereby by training).

In order to create agency's layer, can utilize different principles.For example, can place under the single item name with all agencies that inherit single layer.Alternatively, each agency can have the number of its place layer, and this number can be one in the inspection condition.

In one aspect, in RIDL, there are not " for whole (for all) " structures.Usually, can not visit all agencies, because may in the middle of such action, create or destroy the agency.Therefore, by the own tabulation that determines to keep the agency that it is connected to of agency.Can pass such tabulation.For example, can keep up-to-date (for example, if the layer internal memory that I monitored because think it not in my tabulation, then adds it to tabulation any agency) by using " any " operational symbol to tabulate always.

From writing the study agency: the genetic evolution of software---aspect

Introduce

Briefly, being programmed in two and working in principle of heredity: sudden change causes little random variation; Cross-adaptation former generation, and some part by adopting a former generation and some part of another former generation are created single offspring.

Based on the relevant parameter of different application programs, can determine the successful factor of acting on behalf of.Allow the most successful agency's " breeding ", and two principles above using are created the offspring.Change existence, wherein, if a large amount of former generation is extremely successful, then they do not move to the next generation with changing.The success of measurement a new generation, and a new generation once more can be bred again and be created another generation.Generally speaking, although agency expected life may be many generations sometimes, for each for previous generation death.Just as can be seen, Yi Chuan programming provides and has allowed software to be evolved into the mode of more efficient software automatically.

Trigger condition as the dna mutation basis

Aforesaid, can be used for the programming of heredity based on the multi-agent system of behavior.They provide the difference between the agency, and behavior has formed the discrete area of function in the agency.This provides and can guide sudden change and crossing operation symbol to become to revise more effective information than the source code of blindness.

In one embodiment, a large amount of classifications of acting on behalf of has been supposed in the programming of heredity, and each is acted on behalf of classification and has only an example.Therefore, each agency is independent and unique.When using mutant or intersection, except as otherwise noted, use one of them former generation's main body.Agency initial population or comprise having the behavior (for example neugent) that comprises the main body of learning code, perhaps comprise many behaviors of the little trick of adopting all kinds.

In one embodiment, the sudden change operational symbol is to an agency's a behavior job.In one aspect, define a large amount of sudden change operational symbols, it is used specific to the frequency of application program and works randomly in this colony, and for example: the title of the sensor that (a) takes place in the behavior (usually in trigger condition) is substituted by the title of the sensor of another existence.Constantly make this and replace, so all generations all are replaced so that the logic of software is kept intact.Sensor substitutes with the sensor by same type only.(b) title of the behavior that takes place in behavior in the trigger condition is replaced by the title of the behavior of another existence.(c) if mention a sensor, then wait for the different incident of same sensor in the time portion of trigger condition.Therefore, can or in " sensor.changes ", perhaps in " sensor.event ", change " sensor.updates ".(d) if mention a behavior, then wait for the different event of same behavior in the time portion of trigger condition.Therefore, can be in the middle of other or " behavior.completes " or " behavior.event " in change " behavior.activates ".(e) can abandon trigger condition " time " part incident.(f) can abandon trigger condition " condition " part condition.(g) can add subsidiary condition about already present any sensor in " time " of trigger condition part.(h) additional events of the behavior that exists or sensor can be added to " time " part of trigger condition.(i) can in the agency, create new sensor, and sensor be added to the time conditions of the behavior.Can come from the sudden change of at first appointment to the renewal of this sensor.This sensor is public or special-purpose according to certain possibility.

Agency level is intersected

In one embodiment, for example, adopt a large amount of behaviors that come from a large amount of behaviors of an agency and come from another agency, can from two agencies, construct a new agency.These behaviors are integrated among the new agency.Except the localized sensor of in any of these behavior, not using, all local sensors of two behaviors are all copied to new agency.

Basic behavior level intersects

This intersects with two behavior work.Can create a new behavior by the part copy of the trigger condition of two behaviors is merged into a new trigger condition.In one embodiment, the main body of new behavior is taken out from of two former generation.Do not touch the code within the main body, algorithm is kept intact.If the former generation who is replicated has " completeWhen " clause, then can duplicate this clause samely.This has guaranteed to keep the fault processing that is associated with this algorithm.Sudden change on the sensor name also is applicable to completeWhen clause.

The behavior level of order intersects

Another crossing operation symbol can allow two former generation that order is arranged.In one embodiment, this crossing operation symbol adopts a former generation, and at the end of this former generation's main body, its places " continueWhen " statement of the trigger condition with second former generation.Then, it adds second former generation's main body.Then, additional two former generation's whole " completeWhen " clause.

The behavior level sudden change of order

When behavior had " continueWhen " statement, deletion was from the beginning of main body, perhaps from " continueWhen " statement, up to next " continueWhen " statement or up to the code of the ending of main body.

Can use other operational symbol.Key is that the trigger condition of RIDL and grammer allow algorithm to be defined in its clearly point that can be pasted together code safely of there, and can not cause the software sudden change from the syntax and semantics level.

The group of the extension in the activity

Use the notion of similar group to make the programming of the heredity of multi-agent system become possibility.

In one embodiment, since the representative that the developer provides source code for the program of heredity, the source code that the program of heredity can be visited it.The program of heredity makes a change source code, and recompilates this code.When doing like this, it is useful utilizing inheritance for the program of heredity.

After compiling, start this new program, and created new group thus.This group is similar to original group usually.Because used inheritance, the classification of acting on behalf of of old group is kept intact basically, but has created new offspring.

Next, make all agencies all move to new group.After this took place, old group was destroyed.End product is that our agency remains identical, but be in now they need with their environment of offspring competition in.

The agents document system aspects

When file system during based on database, as usually like this, for example, in the current version of a Microsoft _ form, so can use towards agency's database principle to come to the file allocation behavior.For example, file can monitor that it is own and determine whether it needs back it up oneself, perhaps repairs it oneself, perhaps notifies the user some condition, perhaps comes self-management with other method.This burden that will advantageously make the PC maintenance is away from the user.

Though described the present invention according to embodiment exemplary, it is not limited in the there.In fact, should explain largo that additional claim comprises other modification of the present invention and embodiment, they can be made by those skilled in the art under the prerequisite of the scope that does not break away from equivalent of the present invention.

Claims (40)

1. But 1. the computer-readable medium that has the computing machine operating part, but the computing machine operating part comprises:

   At least one agency has Sensor section and at least one behavior part that at least one comprises target or change method part;

   Wherein, at least one Sensor section produces at least one incident based at least one from the value that target or change method partly produce at least in part, and at least one behavior part determines whether to activate the thread of execution at least in part based on the incident from least one generation of at least one Sensor section.
2. 2. computer-readable medium according to claim 1, wherein, at least one behavior partly determines whether to write down the incident of at least one generation.
3. 3. computer-readable medium according to claim 1, wherein, at least one incident is in change or the update event.
4. 4. computer-readable medium according to claim 1, wherein, at least one behavior part produces outside the agency of Sensor section at least one incident.
5. 5. computer-readable medium according to claim 1, wherein, the activation of at least one behavior part comprises that producing at least one calls.
6. 6. computer-readable medium according to claim 5, wherein, at least one Sensor section can partly be activated by its target or change method, so that small part ground calls at least one incident that produces based at least one.
7. 7. computer-readable medium according to claim 6 wherein, is included at least one Sensor section among the agency outside at least one agency who calls generation behavior part.
8. 8. computer-readable medium according to claim 1, wherein, behavior part can be at least in part comprises or recovers at least one other behavior part or agency based on the incident from least one generation of at least one Sensor section.
9. 9. computer-readable medium according to claim 1, wherein, as long as the thread of carrying out activates, at least one behavior part just produces state event, this state event can be by at least one other behavior partly receive.
10. 10. computer-readable medium according to claim 1, wherein, as long as the thread of carrying out is finished, at least one behavior part just produces state event, this state event can be by at least one other behavior partly receive.
11. 11. computer-readable medium according to claim 1, wherein, at least one behavior part determines whether to activate the thread of execution based on trigger condition independently.
12. 12. computer-readable medium according to claim 11, wherein, independently trigger condition can also be determined priority state for the activation of the thread of specific execution, and wherein, can be based on the activation priority state of the thread of a plurality of execution and sequentially carry out them.
13. 13. computer-readable medium according to claim 12, wherein, at least one behavior partial interior or outside ContinueWhen, resumeWhen and in the complete When statement at least one can be operated based on the activation priority state of the thread of carrying out and be come synchronously them.
14. 14. computer-readable medium according to claim 11, wherein, independently trigger condition comprises at least one time statement and at least one conditional statement, wherein, it is movable that the time statement points out that incident that independently trigger condition responded becomes, and conditional statement is based on predetermined filter value.
15. 15. computer-readable medium according to claim 11, wherein, independently to require the incident of a plurality of generations to become movable for trigger condition.
16. 16. computer-readable medium according to claim 11, wherein, independently trigger condition is based on the local perception of at least one behavior part.
17. 17. computer-readable medium according to claim 14, wherein, at least one behavior part trigger condition independently become once more movable before, activate the thread of carrying out for the independently trigger condition of activity.
18. 18. computer-readable medium according to claim 1, wherein, at least one behavior and Sensor section are defined at least one key word, wherein, at least one key word at least one of particular event of pointing out particular agent, at least one behavior or sensor and being used for activating trigger condition independently.
19. 19. computer-readable medium according to claim 18, wherein, at least one key word can be operated and point out that at least one agency institute is ignorant, any one in behavior or Sensor section, agency or the incident.
20. 20. computer-readable medium according to claim 18, wherein, at least one key word can be operated and point out the predetermined classification of acting on behalf of.
21. 21. computer-readable medium according to claim 20, wherein, the predetermined particular agent of acting on behalf of in the classification can be pointed out at least one key word.
22. 22. computer-readable medium according to claim 18, wherein, the time that can activate of pointing out specific behavior or sensor can be operated at least one key word.
23. 23. computer-readable medium according to claim 1, wherein, at least one agency can produce incident.
24. 24. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior more, comprising:

    The code segment that is used to the request that receives; With

    Carry out framework, comprising:

    A plurality of agencies with at least one Sensor section comprise at least one target or change method part and at least one routine, detailed or redundant behavior part;

    Wherein, at least one target or change method partly produce at least one value, at least one Sensor section produces at least one incident based on the value from least one generation of at least one target or change method part at least in part, and at least one behavior part determines whether to activate the thread of execution at least in part based on the incident from least one generation of at least one Sensor section.
25. 25. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 24 more, wherein, receives request from least one agency.
26. 26. the computer program of on computer-readable medium, realizing, be used to realize the computing system of acting on behalf of based on behavior of claim 24 more, wherein, carrying out framework becomes towards agency's language construction at object-oriented language structure higher slice, wherein, object and agency are being the parts that can exchange in agency's language construction.
27. 27. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, comprises based on the object-oriented language structure towards agency's language construction.
28. 28. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, the agency forms the agency's that can duplicate group.
29. 29. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 28 more, wherein, the agency comprises the agency's that can move group between the group of duplicating.
30. 30. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 29 more, wherein, the agency can move between group by knowing target group identification parameter.
31. 31. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 29 more, wherein, the agency can ferret out group.
32. 32. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, the system of layering allows that they are own to work by acting on behalf of group's breeding in grid computing.
33. 33. the computer program of on computer-readable medium, realizing, be used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, the agency can be movable between group by using at least one counterfoil, wherein, counterfoil can keep at least one sensor and automatically produce.
34. 34. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, those agencies become to gather together and realize the part of the name space of serving.
35. 35. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, service can be pointed out by the key word or the attribute in note name space.
36. 36. the computer program of on computer-readable medium, realizing, be used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, at least one agency can operate the neuron of representing neural network, at least one agency has at least one trigger value as at least one sensor, and at least one behavior part can operate at least one incident that comes from least one trigger value at least one lower level is made response.
37. 37. the computer program of on computer-readable medium, realizing, be used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, at least one agency utilizes at least one sudden change at least one behavior or crossing operation to accord with to realize at least one from writing the study agency, thereby allows computer program automatically to develop.
38. 38. the computer program of realizing on computer-readable medium is used to realize the computing system of acting on behalf of based on behavior of claim 26 more, wherein, at least one file is distributed at least one behavior managed it oneself.
39. 39. the database towards the agency comprises:

    The a plurality of sections that comprise at least one agency;

    At least one agency has at least one and comprises that target or method change the Sensor section of part;

    Wherein, at least one Sensor section can be operated at least in part and produce at least one incident based on the value that comes from target or method change at least one generation partly.
40. 40. according to the described database of claim 39, wherein, at least one agency comprises the behavior part.