Docstoc

UbiCC camera ready ID 270 270

Document Sample
UbiCC camera ready ID 270 270 Powered By Docstoc
					                          LRN/R-MAUDE BASED APPROACH
                          FOR MODELING AND SIMULATION
                            OF MOBILE CODE SYSTEMS

                                   Laïd Kahloul1 and Allaoua Chaoui2
                          1
                          Computer Science Department, Biskra University, Algeria
                                          kahloul2006@yahoo.fr
                       2
                        Computer Science Department, Constantine University, Algeria
                                        a_chaoui2001@yahoo.com


                                                ABSTRACT
         Code mobility technologies attract more and more developers and consumers. Numerous
        domains are concerned, many platforms are developed and interest applications are realized.
        However, developing good software products requires modeling, analyzing and proving steps.
        The choice of models and modeling languages is so critical on these steps. Formal tools are
        powerful in analyzing and proving steps. However, poorness of classical modeling language to
        model mobility requires proposition of new models. The objective of this paper is to provide a
        formal approach based on LRN and R-Maude. LRN (Labeled Reconfigurable Nets) is a
        specific formalism that we propose to model different kinds of code mobility. R-Maude
        (Reconfigurable Maude) is a system that we devlop to encode and simulate LRN-models.

          Keywords: code mobility, modeling mobility, LRN, R-Maude.
                                                         found in process algebra based model and state
                                                         transition model. For the first one, π-calculus [13]
1 INTRODUCTION                                           is the famous one, and for the second, high-level
                                                         Petri net (with many kinds) can be considered the
     Code mobility is one of the attracting fields for   good representative. π-calculus is an extension for
computer science researchers. Code mobility              CCS (communicating concurrent systems) [12].
technology seems an interest solution for                CCS allows modeling a system composed of a set
distributed applications facing bandwidth problems,      of communicating process. This communication
users' mobility, and fault tolerance requirement.        uses names (gates) to insure synchronization
Numerous platforms were been developed [17].             between processes. In π-calculus information can
Such platforms allow the broadcasting of this            been exchanged through gates. The key idea is that
technology in many domains (information                  this information can be also a gate. With this idea,
retrieving [9], e-commerce [11], network                 process can exchange gates. Once these gates
management [22], …). Software engineering                received, they can be used by the receiver to
researches have provided some interest design            communicate. In an extension of π-calculus, HOπ-
paradigms influencing the development of the field.      calculus [15], processes can exchange other
The most recognized paradigms [7] are: code on           processes through gates (the exchanged processes
demand, remote evaluation, and mobile agent. To          called agents).
avoid ad-hoc development for code mobility                    To model mobility with Petri nets, high level
software, many works attempt to propose                  PNets were proposed. The most famous are Mobile
methodologies and approaches ([16], [21], [14],          Nets (variant of coloured Petri nets) [1] and
…). Indeed, these approaches are mostly informal.        Dynamic Petri nets. In mobile Petri nets, names of
They lack in analyzing and proving system                places can appear as tokens inside other places.
proprieties. Enhancing development process with          Dynamic Petri nets extend mobile Petri nets. In this
formal tools was an attractive field in code mobility    last one, firing a transition can cause the creation of
researches.                                              a new subnet. With high-level Petri nets, mobility
     Traditional formal tools witch were massively       in a system is modeled through the dynamic
used to model and analyze classical systems seem         structure of the net. A process appearing in a new
to be poor to deal with inherent proprieties in code     environment is modeled through a new subnet
mobility systems. Works on formal tools attempt to       created in the former net by firing a transition.
extended classical tools to deal with code mobility      Many extensions have been proposed to adapt
proprieties. The most important proposition can be       mobile Petri net to specific mobile systems:
                                                         Elementary Object Nets [18], reconfigurable nets
                                                         [3], Nested Petri Nets [10], HyperPetriNets [2], …
                                                         With respect to [20], all these formalisms lack in


                    Ubiquitous Computing and Communication Journal
security aspect specification. To handle this aspect      Formal Definition:
in code mobility, recently Mobile Synchronous             Let N1, N2, … Nk be a set of nets.
Petri Net (based on labeled coloured Petri net) are       for each i: 1, …, n : Ni = (Pi, Ti, Ai), such that :
proposed [19].                                                1. Pi = {pi1, pi2, …, pin} a finite set of places,
     The objective of this work is to treat to aspects        2. Ti = STi∪RTi
of code mobility: modeling and simulation. We try                • STi={sti1, sti2, …, stim} a finite set of
to propose a formal approach in witch we define                  standard (ordinary) transitions,
two formalisms : Labeled Reconfigurable Nets                     • RTi = {rti1, rti2, …, rtir} a finite set
(LRN) and Reconfigurable Maude (R-Maude).                        (eventually empty) of “reconfigure
Firstly, LRN will be used to model the system then               transitions”,
R-Maude will encode and simulate this model. Our              3. Ai ⊆ Pi x Ti ∪ Ti x Pi.
formalism “labeled reconfigurable nets” with a
different semantic from the one presented in [3] is       Definition 1 (Unit): a unit UN is a net Ni that has a
dedicated to model code mobility systems. We              specific transition stij denoted starti. So
attempt to propose to model mobility in an intuitive      Ti={starti}∪STi∪RTi.
and an explicit way. Mobility of code (a process or       Définition 2 (Environment): an environment E is
an agent) will be directly modeled through                a quadruplet E=(GP, RP, U, A)
reconfiguration of the net. We allow adding and              • GP = {gp1, gp2, …, gps} a finite set of
deleting of places, arcs, and transitions at run time.       specific places : “guest places ”;
R-Maude is an extension for Maude that we
                                                             • RP = {rp1, rp2, …, rps} a finite set of specific
propose and prototype in order to encode and
                                                             places : “resource places”;
simulate LRN models.
                                                             • U = { N1, N2, … Nk} a set of nets.
     The rest of this paper is organized as follows.
Section 2 starts by presenting the definition of the         • A⊆ GP x StrT∪RPxT. Such that :
formalism LRN. In section 3 we show how LRN                  StrT={start1, start2, …, startk} and T=ST1∪RT1
can be used to model the three mobile code                   ∪ ST2∪RT2∪ … ∪ STk∪RTk
paradigms: “remote evaluation”, “code on                  Definition 3 (Labeled reconfigurable net):
demand”, and “mobile agent”. Section 4 presents
                                                          A labeled reconfigurable net LRN is a set of
the idea and foundation of R-Maude, and section 5
discusses the prototype and shows an example. In          environments. LRN={E1, E2, …, Ep} such that
section 6, we present some related works. We                  • There exist at least one net Ni in LRN such
conclude this work and give some perspectives, in                  that RTi ≠ ∅;
section 7.                                                    • For each rtij ∈ RTi, rtij has a label
                                                                   <N,Ee,Eg,ψ,β>, such that N is a unit, Ee
2   LABELED RECONFIGURABLE NETS                                    and Eg are environments, ψ a set of places,
                                                                   β a set of arcs.
     Labeled reconfigurable nets are an extension of
Petri nets. Informally, a labeled reconfigurable net      Dynamic of labeled reconfigurable nets:
is a set of environments (blocs of units).                Let LRN = {E1, E2, …, Ep} be a labeled
Connections between these environments and their          reconfigurable net,
contents can be modified during runtime. A unit is a      Let Ei = (GPi, RPi, Ui, Ai) be an environment in
specific Petri net. A unit can contain three kinds of     LRN,
transitions (a unique start transition:      , a set of      • GPi = {gp1i, gp2i, …, gpsi};
ordinary transitions:       , and a set of reconfigure       • RPi = {rp1i, rp2i, …, rppi} ;
transitions:       ).
                                                             • Ui = { N1i, N2i, … Nki};
     Preconditions and post-conditions to fire a start
or an ordinary transition are the same that in Petri         • Ai ⊆ GPi x startsi ∪ RPi x Ti ∪ Ti x RPi,
nets. Reconfigure transitions are labeled with labels             where:
that influence their firing. When a reconfigure                    Sartsi = {start1, start2, ..., startk} and
transition is fired, a net N will be (re)moved from
                                                                i
                                                              T ={STi1, STi2, ..., STik}∪{RTi1, RTi2, ..., RTik}
an environment E towards another environment E’.          Let RTji be the non empty set of reconfigure
The net N, the environment E and E’ are defined in        transitions associated with the net Nji.
the label associated to the transition. After firing a          RTji={rtj1, rtj2, …, rtjr}.
reconfigure transition, the structure of the labeled
reconfigurable net will be updated (i.e some places,      Let rtjm < N, Ee, Eg, ψ, β> be a reconfigure transition in
arcs, and transitions will be deleted or added). Here     RTji, such that :
after we give our formal definitions of the concepts:        • Ee=(GPe, RPe, Ue, Ae);
unit, environment and labeled reconfigurable net.            • N=(P, T, A) and N∈Ue;
After the definition, we present the dynamic aspect          • Eg=(GPg, RPg, Ug, Ag);
of this model.



                     Ubiquitous Computing and Communication Journal
    • ψ ⊆ RPe; ψ=ψr ∪ψc. (ψr denotes removed              3.1. Remote Evaluation
    places and ψc denotes cloned places).
    • β is a set of arcs. β ⊆RPe x T∪RPg x T.                 In remote evaluation paradigm, an execution
                                                          unit EU1 sends another execution unit EU2 from a
Let strt be the start transition of N.                    computational environment CE1 to another one
Conditions to fire rtjm<N, Ee, Eg, ψ, β>:                 CE2. The reconfigure transition rt is contained in
In addition to the known conditions, we impose that       the unit modeling EU1, and EU2 will be the first
there exists a free place pg in GPg; witch means: for     argument in rt’s label.
each t∈ startsg, (pg,t)∉Ag.                                  Example 4.1: Let us consider two computational
                j
After firing rt m:                                        environments E1 and E2. Firstly, E1 contains two
In addition to the known post-condition of a              execution units EU1 and EU2; E2 contains an
transition firing, we add the following post-             execution unit EU3. The three execution units
condition:                                                execute infinite loops. EU1 executes actions {a11,
    LRN will be structurally changed such that:           a12}, EU2 executes actions {a21, a22, a23}, and EU3
      If Ee and Eg denote the same environment then       executes actions {a31, a32}.         a21 requires a
             LRN will be not changed;                     transferable resource TR1 and a non-transferable
      Else:                                               resource bound by type PNR1 witch is shared with
                                                          a11. a22 and a12 share a transferable resource bound
    1) Ug Ug∪{N}; Ue Ue/{N};
                                                          by value VTR1, and a23 requires a non-transferable
    2) Ag Ag∪(pg, strt);
                                                          resource NR1. In E2, EU1 requires a non-
    3) Let DA ={(a, b)∈ Ae/ (a∉ψ and b∉ψ) and             transferable resource bound by type PNR2 to
      ((a∈N and b∉N) or (a∉N and b∈N))}, Ae=Ae-           execute a31. PNR2 has the same type of PNR1.
      DA. DA –deleted arcs- to be deleted after              The system will be modeled as a labeled
      moving N.                                           reconfigurable net LRN. LRN contains two
    4) RPg RPg∪ψ; RPe RPe/ψr                              environments E1, E2 that model the two
    5) if ALRN is the set of arcs in LRN,                 computational environments (CE1 and CE2). Units
      ALRN ALRN∪β .                                       EU1 and EU2 will model execution units EU1 and
                                                          EU2, respectively. In this case, the unit EU1 will
3   MODELING MOBILITY PARADIGMS                           contain a reconfigure transition rt<EU2,E1,E2,ψ,β>; such
    WITH LABELED RECONFIGURABLE                           that:
    NETS                                                      1. E1 =(RP1, GP1, U1, A1); RP1= {TR1, PNR1,
     A mobile code system is composed of                          VTR1, NR1}. U1 = {EU1, EU2};
execution      units      (EUs),    resources,     and        2. E2 = (RP2, GP2, U2, A2); RP2={ PNR2}. GP2
computational environments (CEs). EUs will be                     ={PEU1}.
modeled as units and computational environments
as environments. Modeling resources requires using            3. ψr={TR1}, ψc={VTR1};
a set of places.                                              4. β={(PEU1,str2), (PNR2,a21), (NR1, a23)}.
     Reconfigure transitions model mobility actions.
The key in modeling mobility is to identify the             Fig. 1 shows the configuration before firing rt,
label associated with the reconfigure transition. We      and Fig. 2 shows the configuration after the firing.
must identify the unit to be moved, the target
computational environment and the types of
binding to resources and their locations. This label
depends on the kind of mobility.
     In general, a reconfigure transition rt is always
labeled <EU, CE, CE’, ψ, β>, such that:
    • EU: the execution unit to be moved.
    • CE, CE’: respectively, resource and target
    computational environments.
    • ψ: will be used to model transferable
    resources. So ψ is empty if the system has no
    transferable resource.
    • β: models bindings after moving.
   The execution unit that contains rt and the EU
that represents the first argument in the label will be
defined according to the three design paradigms:
remote evaluation (REV), code on demand (COD),
and mobile agent (MA).



                      Ubiquitous Computing and Communication Journal
    PEU1
                                    E1                                E2
                                                 PEU1                                                                       PEU1
                                  PEU2                                             PEU1               E1                                            E2
         str1                                                                                                                              PEU2
                                                               PEU2                                   PEU2                  str1
  P11                               str2                                               str2
                                                                 str3                                                                PNR1           str3
         rt<EU2, E1, E2, ψ, β>                      PNR2                                                             P21
                                                                              P11                                            TR1
                  TR1               P21                                                                                                             P21
  P12                                                            P31
                                    a21                                                rt<EU2, E2, E1, ψ, β>          a21
                   PNR1                                                                                                                             a31
                                                                                           PNR2                      P22
   a11                                                            a31         P12
                 VTR1                                                                                                              VTR1             P22
                                     P22
  P13                                                            P32
                                                                              a12                                     a22
                                     a22                                                                                                            a32
                    NR1                                           a32
  a12                                                                                                                P23
                                    P23
                                                                                                                                   NR1              P23
                                     a23
                                                                                                                      a23
                                                                                                                                                    a33

                Figure 1: REV-model before firing rt
                                                                                         Figure 3: COD-model before firing rt
    PEU1                     E1                                       E2
                                             PEU1                                       PEU1                         E1      PEU1           PEU2          E2
                     PEU2                                                                                   PEU2
                                                               PEU2
         str1                                                                          str1
                                                 str2                                                                               PNR1          str3
  P11                                                            str3        P11                                   str2
                                         P21            PNR2
                                                                                                                                                  P31
         rt<EU2, E1, E2, ψ, β>                                                      rt<EU2, E2, E1, ψ, β>
                                                                 P31         a11                                      TR1
                                           a21                                                                                                    a31
  P12                                                                                     PNR2
                                                        TR1                  P12
                                         P22                                                                        a21            VTR1
                   PNR1                                           a31                                                                             P32
                                                                                                            P23
   a11           VTR1                                            P32                                               VTR1
                                         a22            VTR1                 a12
                                                                                                                                                  a32
  P13
                                         P23                      a32                                        a22
                           NR1                                                                                                     NR1            P33
  a12
                                                                                                            P24
                                                 a23
                                                                                                                                                   a33
                                                                                                            a23
                Figure 2: REV-model after firing rt

3.2. Code On Demand
    In code-on-demand paradigm, an execution unit                                         Figure 4: COD-model after firing rt
EU1 fetches another execution unit EU2. The
reconfigure transition rt is contained in the unit                            The transition rt<EU2, E2, E1, ψ, β> means that EU1
modeling EU1, and EU2 will be the first argument in                        will demand EU2 to be moved from E2 to E1. In this
rt’s label. If we reconsider the above example, the                        case, ψ={TR1, VTR1}, β={(PEU2, str2), (PNR2,
unit EU1 will contain a reconfigure transition rt<EU2,                     a21), (NR1, a23)}. Fig.3 shows the configuration
E2, E1, ψ, β>. Fig. 3 and Fig. 4 shows the model                           before firing rt, and Fig.4 shows the configuration
proposed for this system.                                                  after the firing.

                                                                           3.3. Mobile Agent
                                                                              In mobile agent paradigm, execution units are
                                                                           autonomous agents. The agent itself triggers
                                                                           mobility. In this case, rt –the reconfigure
                                                                           transition- is contained in the unit modeling the
                                                                           agent and EU (the first argument) is also this agent.


                                 Ubiquitous Computing and Communication Journal
   Example 4.2: let E1 and E2 two computational                          Fig. 6 shows the configuration after the firing.
environments. E1 contains two agents, a mobile
agent MA and a static agent SA1; E2 contains a                                                                PA2                          E2
unique static agent SA2. The three agents execute
                                                                                                                str1                PA1
infinite loops. MA executes actions {a11, a12, a13 },
SA1 executes actions {a21, a22, a23}, and SA2                                                                                              str3
                                                                                                       P11
                                                                         PA1                 E1
executes actions {a33, a32}. To be executed, a11                                     PA2
                                                                                                                                     P31
require a transferable resource TR1 and a non-                                                               rt<A, E1, E2, ψ, β >
transferable resource bound by type PNR1 witch is                                          str2
shared with a21. a12 and a22 share a transferable                                                      P12                           a31
                                                                                 P21                                      PNR2
                                                                      PNR1                                          TR1
resource bound by value, and a13 and a23 share a
                                                                                                                                    P32
non-transferable resource NR1. In E2, SA2 requires a                                                   a11
                                                                                           a21
non-transferable resource bound by type PNR2 to
execute a32. PNR2 has the same type of PNR1.                                   P22         VTR1        P13                                 a32
   The system will be modeled as a labeled                                                                          VTR1
reconfigurable net LRN. LRN contains two                                       a22
                                                                                                       a12
environments E1 and E2 that model the two
                                                                               P23
computational environments. In this case the unit A                                              NR1
                                                                                                        P4
that models the mobile agent A will contain a
                                                                               a23
reconfigure transition rt < A, E1, E2, ψ, β >; such
that:                                                                                                         a13
    1. E1 =(RP1, GP1, U1, A1); RP1 contains at least
        four places that model the four resources.
        Let TR1, NR1, PNR1 and VTR1 be these                                         Figure 6: MA-model after firing rt.
        places. GP1 contains at least a free place PA1
        modeling that A can be received, and                         4    RECONFIGURABLE MAUDE
        U1={A}.
    2. E2=(RP2,GP2, U2, A2); RP2={PNR2},                                   Maude [23] is a high-level language and high-
        GP2={PA2}.                                                   performance system supporting executable
    3. ψr={TR1}, ψc={VTR1};                                          specifications and declarative programming in
    4. β={(PA2, str1), (PNR2, a11), (NR1, a13)}.                     rewriting logic [24]. Maude also supports
                                                                     equational specification, since rewriting logic
  Fig. 5 shows the configuration before firing rt.                   contains equational logic. The underlying
                                                                     equational logic chosen for Maude is membership
                                                                     equational logic, that has sorts, subsorts, operator
          PA1                         E1                        E2   overloading,     and     partiality   definable     by
                                             PA2
                                                    PA1              membership and equality conditions. Modules of
         str1                                                        Maude are theories in rewriting logic. The most
                                                                     general Maude module are called system modules.
   P11
                                                         str2        A rewrite theory is a triple T=(Ω, E, R), where Ω is
                                PA2                P31
                                                                     a signature, E a set of equations and R a set of
         rt<A, E1, E2, ψ, β >                                        rewriting rules. The equations E in the equational
                 PNR1                 str3   PNR2 a31                theory (Ω, E) are presented as a union E=A∪E’,
   P12     TR1                                                       with A a set of equational axioms introduced as
                                  P21              P32               attributes of operators in the signature Ω. E’ is a set
   a11                                                               of Church-Rosser equations assumed to be
                                                                     terminating modulo the axioms A. Considering the
                                  a21                     a32
   P13                                                               Maude syntax, a system module has the form mod
                VTR1              P22                                T endmod. Maude contains a sublanguage of
                                                                     functional modules and object modules. A
   a12                                                               functional module have the form fmod =(Ω, E)
                                      a22
                                                                     endfm and an object module have the same form
                                                                     as system module. Maude can be used as a tool for
                NR1
                                                                     the specification and verification of distributed
   a13                                                               systems. The dynamic of the distributed system is
                          a23
                                                                     specified by rewrite rules. Rewrite rules model
                                                                     transitions from one state to another state, during
                                                                     the execution of the distributed system.
                                                                           Maude has been extended to deal with some
           Figure 5: MA-model before firing rt                       aspects not considered in former version. Real time



                                Ubiquitous Computing and Communication Journal
Maude [25] is a system to specify and analyze real       the LAN. The specification (or their parts) are
time and hybrid systems. Mobile Maude [5] is an          transferred in messages between machines, using
extension of Maude for mobile systems                    UDP protocol.
specification. Mobile Maude is an object oriented              The interpreter realized for R-Maude can be
high level language with asynchronous message            used to interpret Maude specifications. The major
passing. The key feature of mobile Maude is that it      different is that in this newest interpreter, we have
deals with various security aspects. Cryptographic       added the interpretation of R-Rules. The label of an
authentication protects machine from malicious           R-Rule precedes the rule, and it has the form [MT|
mobile code, redundant checks insure reliability         L| IP@| S]. Semantics of these parameters is : MT:
and integrity of computations, and public-key            mobility type (MA, COD, REV, …), L: a multi-set
infrastructure service protects communications.          of operations and rules to be moved, cloned or
      In this section we propose an encoding of          removed from or to the local host, IP@: IP address
Labeled Reconfigurable Nets in a Maude-based             of distant host, S: sources to move or to remove
language. We call the inspired language                  from or to the local host. When specifications (or
“Reconfigurable Maude” (R-Maude). We want to             part of them) are moved, some resources (R)
profit from the powerful of Maude (as a meta-            necessary to firing some rules become far (on an
language). We extend Maude to support the                other host). IP address of the far host appears with
translation of LRN and their simulation. R-Maude         the concerned resource in the form: R[IP@].
enrich Maude with new kind of rewriting rules.                 To encode LRN we adopt the same rules
Theses rules are called Reconfigurable rules (R-         proposed to translate Petri Nets into Maude in [23].
Rules). The semantic of these rules is similar to that   The newest is that R-transition will be translated in
of Reconfigurable transition in LRN. When a R-           R-Rules. Here after, we present the encoding of
rule is executed, the R-Maude specification will be      Fig.5’s example in R-Maude prototype. We
updated in different ways, this will depend on label     consider that the two environments E1, E2 are
associated with this rule.                               specified as two specifications on two hosts (Host1
      A specification in R-Maude is a set of             and Host2). Host1 has the IP address : 192.168.0.1,
Reconfigurable rewrite theories (R-theories). An R-      and Host2 has the IP address : 192.168.0.2.
Theory RT is a triple (Ω, E, R) as like a rewrite              On Host1, we have the specification:
theory. The different resides in the set R. R will         mod E1
contain two kinds of rules: standard Rules S-Rules         sort Place Marking .
(well known rules of Maude) and Reconfigurable             subsort Place << Marking .
rules R-Rules. A R-Rule rλ is composed of a label          op _,_ : Marking Marking ->
λ=<d, RT1, RT2, S> and a rule t t’. In the label                      Marking .
λ, RT1 and RT2 are two R-Theorie, S is a segment           ops PA1,P11,P12,P13,P14,PA2,P21,
                                                              P22,P23,TR1,VTR1,PNR1,NR1:->Place
of a theory, and d a specific parameter. The               rl [str1] : PA1=>P11 .
segment S can be a set of sorts, rules, variables,         rl [rt][MA|192.186.0.2|{{P11-
operators that can be an R-theory or not. When rλ                      P14},{str1-
is fired, the specification can be updated in several                  a13}}|{TR1,VTR1}] :
ways. Updating specification means that their R-                       P11=>P12 .
theories will be changed. This change depends on           rl [a11] : P12, TR1, PNR1=>P13 .
                                                           rl [a12] : P13, VTR1=>P14 .
λ. In general, when rλ is fired, the segment S will        rl [a13] : P14, NR1=>PA1 .
move from RT1 to RT2 or the inverse. The d                 rl [str2]: PA2=>P21 .
parameter can be used to express direction of this         rl [a21] : P21, PNR1=>P22 .
move.                                                      rl [a22] : P22, VTR1=>P23 .
                                                           rl [a23] : P23, NR1=>PA2 .
5   PROTOTYPING R-MAUDE                                    endmod
                                                         and on Host2, we have the specification :
      We have prototyped R-Maude. The prototype
                                                           mod E2
is a system composed from a text editor and an             sort Place Marking .
interpreter. The editor is used to enter the               subsort Place << Marking .
specification and commands. The interpreter                op _,_ : Marking Marking ->
executes commands, and through this updates                           Marking .
specifications. The system was experimented on a           ops PA1,PA2,P31,P32,PNR2 : -> Place.
LAN (Local Area Network), composed of a few                rl [str3] : PA2=>P31 .
machines. The system is installed on all hosts. So         rl [a31] : P31=>P32 .
                                                           rl [a32] : P32, PNR2=>PA2 .
the specifications are edited ever where. On every         endmod
hosts, commands can be executed. The execution of
commands will create the system dynamic. This              As an example of a command, we have “rw
dynamic can be shown as migration of                     PA1” on Host1. The execution of this command
specification’s part (or ever else at whole) through



                     Ubiquitous Computing and Communication Journal
will produce respectively on Host1, and Host2 the       towards another locality. The destination locality is
two specifications:                                     given through a token in an input place of the go
    mod E1                                              transition. Mobile Petri nets (MPN) [1] extended
    sort Place Marking .                                colored Petri nets to model mobility. MPN is based
    subsort Place << Marking .                          on π-calculus and join calculus. Mobility is
    op _,_ : Marking Marking ->                         modeled implicitly, by considering names of places
        Marking .                                       as tokens. A transition can consumes some names
    ops PA1,PA2,P21,P22,P23,                            (places) and produce other names. The idea is
        VTR1,PNR1,NR1:->Place
    rl [str2]: PA2=>P21 .                               inherited from π-calculus where names (gates) are
    rl [a21] : P21, PNR1=>P22 .                         exchanged between communicating process. MPN
    rl [a22] : P22, VTR1=>P23 .                         are extended to Dynamic Petri Net (DPN) [1]. In
    rl [a23] : P23, NR1=>PA2 .                          DPN, mobility is modeled explicitly, by adding
    endmod                                              subnets when transitions are fired. In their
and                                                     presentation [1], no explicit graphic representation
                                                        has been exposed.
    mod E2                                                   In nest nets [8], tokens can be Petri nets them
    sort Place Marking .                                selves. This model allows some transition when
    subsort Place << Marking .                          they are fired to create new nets in the output
    op _,_ : Marking Marking ->
    Marking .                                           places. Nest nets can be viewed as hierarchic nets
    ops PA1,PA2,P31,P32,PNR2 : -> Place.                where we have different levels of details. Places
    ops VTR1, TR1:-> Place.                             can contain nets that their places can also contain
    ops P11,P12,P13,P14:->Place.                        other nets et cetera. So all nets created when a
    rl [str3] : PA2=>P31 .                              transition is fired are contained in a place. So the
    rl [a31] : P31=>P32 .                               created nets are not in the same level with the first
    rl [a32] : P32, PNR2=>PA2 .
    rl [str1] : PA1=>P11 .                              net. This formalism is proposed to adaptive
    rl [rt][MA|192.186.0.2|{{P11-                       workflow systems.
                P14},{str1-                                  In [3], authors studied equivalence between the
                a13}}|{TR1,VTR1}] :                     join calculus [6] (a simple version of π-calculus)
                P11=>P12 .                              and different kinds of high level nets. They used
    rl [a11] : P12, TR1, PNR2=>P13 .                    “reconfigurable net” concept with a different
    rl [a12] : P13, VTR1=>P14 .
    rl [a13]:                                           semantic from the formalism presented in this
             P14,NR1[192.168.0.1]=>PA1.                 work. In reconfigurable nets, the structure of the net
    endmod                                              is not explicitly changed. No places or transitions
                                                        are added in runtime. The key difference with
Finally, the state of the marking will be : “P12” on    colored Petri nets is that firing transition can change
the Host2. At this point, the two specifications        names of output places. Names of places can figure
continue their execution on the two hosts where         as weight of output arcs. This formalism is
they reside.                                            proposed to model nets with fixed components but
                                                        where connectivity can be changed over time.
6     RELATED WORKS                                          In this work, we have attempted to provide a
                                                        formal and graphical model for code mobility. We
     In [4], the authors proposed PrN                   have extended Petri net with reconfigure labeled
(Predicate/Transition nets) to model mobility. They     transitions that when they are fired reconfigure the
use concepts: agent space witch is composed of a        net. Mobility is modeled explicitly by the
mobility environment and a set of connector nets        possibility of adding or deleting at runtime arcs,
that bind mobile agents to mobility environment.        transitions and places. Modification in reconfigure
Agents are modeled through tokens. So these agents      transition’s label allows modeling different kinds of
are transferred by transition firing from a mobility    code mobility. Bindings to resources can be
environment to another. The structure of the net is     modeled by adding arcs between environments. It is
not changed and mobility is modeled implicitly          clear that in this model created nets are in the same
through the dynamic of the net. In [19], authors        level of nets that create them. Creator and created
proposed MSPN (Mobile synchronous Petri net) as         nets can communicate. This model is more
formalism to model mobile systems and security          adequate for modeling mobile code systems. We
aspects. They introduced notions of nets (an entity)    propose also an extension for Maude, that we call
and disjoint locations to explicit mobility. A system   R-Maude. R-Maude extends Maude with
is composed of set of localities that can contain       Reconfigurable rules (R-rules). When an R-Rule is
nets. To explicit mobility, specific transitions        fired, R-Maude specifications are reconfigured on a
(called autonomous) are introduced. Two kinds of        LAN (Local Area Net).We use R-Maude to encode
autonomous transition were proposed: new and go.        and simulate LRN models.
Firing a go transition move the net form its locality



                     Ubiquitous Computing and Communication Journal
7   CONCLUSION                                         8   REFERENCES

       Proposed initially to model concurrency and     [1] Andrea Asperti and Nadia Busi: Mobile Petri Nets.
distributed systems, Petri nets attract searchers in       Technical Report UBLCS-96-10, Department of
mobility modeling domain. The ordinary formalism           Computer Science University of Bologna, May 1996.
                                                       [2] M.A. Bednarczyk, L. Bernardinello, W. Pawlowski,
is so simple with a smart formal background, but it
                                                           and L. Pomello: Modelling Mobility with Petri
fails in modeling mobility aspects. Many extensions        Hypernets. 17th Int. Conf. on Recent Trends in
were been proposed to treat mobility aspects. The          Algebraic Development Techniques, WADT’04.
key idea was to introduce mechanisms that allow            LNCS vol. 3423, Springer-Verlag, 2004.
reconfiguration of the model during runtime. The       [3] M. Buscemi and V. Sassone: High-Level Petri Nets
most works extends coloured Petri nets and borrow          as Type Theories in the Join Calculus. In Proc. of
π-calculus or join calculus ideas to model mobility.       Foundations of Software Science and Computation
The exchanging of names between processes in π-            Structure (FoSSaCS '01), LNCS 2030, Springer-
                                                           Verlag.
calculus is interpreted as exchanging of place’s
                                                       [4] Dianxiang Xu and Yi Deng: Modeling Mobile Agent
names when some transitions are fired. This can            Systems with High Level Petri Nets. 0-7803-6583-
model dynamic communication channels. In much              6/00/ © 2000 IEEE.
formalism, mobility of process is modeled by a net     [5] Francisco Dur‫ل‬n, Steven Eker, Patrick Lincoln and
playing as token that moves when a transition is           José Meseguer: principles of mobile maude. In
fired. All these mechanisms allow modeling                 D.Kotz and F.Mattern, editors, Agent systems,
mobility in an implicit way. We consider that the          mobile agents and applications, second international
most adequate formalisms must model mobility               symposium on agent systems and applications and
explicitly. If a process is modeled as a subnet,           fourth international symposium on mobile agents,
mobility of this process must be modeled as a              ASA/MA 2000 LNCS 1882, Springer Verlag. Sept
                                                           2000.
reconfiguration in the net that represents the
                                                       [6] Cédric Fournet Georges Gonthier: The Join Calculus:
environment of this process.                               a Language for Distributed Mobile Programming. In
       In this paper, we have presented a new              Applied Semantics. International Summer School,
formalism “labeled reconfigurable nets”. This              APPSEM 2000, Caminha, Portugal, September 2000,
formalism      allows     explicit   modeling     of       LNCS 2395, pages 268--332, Springer-Verlag.
computational environments and processes mobility          August 2002.
between them. We have presented how this               [7] Alfonso Fuggetta, Gian Pietro Picco and Giovanni
formalism allows, in a simple and an intuitive             Vigna: Understanding Code Mobility. IEEE
approach, modeling mobile code paradigms. We               transactions on software engineering, vol. 24, no. 5,
                                                           may 1998.
have focused on bindings to resources and how they
                                                       [8] Kees M. van Hee, Irina A. Lomazova, Olivia Oanea,
will be updated after mobility. We have presented          Alexander Serebrenik, Natalia Sidorova, Marc
an extension for Maude : reconfigurable Maude (R-          Voorhoeve: Nested Nets for Adaptive Systems.
Maude). R-Maude is a distributed system. This              IEEE. ICATPN 2006: 241-260.
system can be used to specification and simulation     [9] P. Knudsen: Comparing Two Distributed Computing
of mobile code system. A prototype for this system         Paradigms, A Performance Case Study; MS thesis,
has been realized. We use this prototype to encode         Univ. of Tromso 1995.
and simulate LRN models. In our future works we        [10]      I.A. Lomazova: Nested Petri Nets. Multi-level
plan to focus on modeling and analyzing aspects. In        and Recursive Systems. Fundamenta Informaticae
                                                           vol.47, pp.283-293. IOS Press, 2002.
modeling aspects, we are interested to handle
                                                       [11]      M. Merz and W. Lamersdorf: Agents, Services,
problems such that modeling multi-hops mobility,           and Electronic Markets: How Do They Integrate?.
process’s states during travel, birth places and           Proc. Int’l Conf. Distributed Platforms, IFIP/IEEE,
locations. On the analysis aspect, we are working          1996.
on a denotational semantics for LRN. For R-            [12]      R. Milner: A Calculus of Communicating
Maude, the current R-Maude can be used only to             Systems. Number 92 in Lecture Notes in Computer
simulate Models. Future works will handle                  Science. Springer Verlag, 1980.
specification analyzing. As a future extension, we     [13]      R. Milner, J. Parrow, and D. Walker: A
think to adapt Maude model-checker to                      calculus of mobile processes. Information and
                                                           Computation, 100:1–77, 1992.
reconfigurable Maude. In [26], we have proposed
                                                       [14]      Reinhartz-Berger, I., Dori, D. and Katz, S.:
extensions for LRN “Temporal LRN”, and in [27],            Modelling code mobility and migration: an
we proposed Coloured LRN. In this sense, we focus          OPM/Web approach. Int. J. Web Engineering and
on using R-Maude to simulate models of these               Technology, Vol. 2 (2005), No. 1, pp.6–28.
extensions.                                            [15]      D. Sangiorgi and D. Walker: The π-Calculus: A
                                                           Theory of Mobile Processes. Cambridge University
                                                           Press, 2001.
                                                       [16]      Athie L. Self and Scott A. DeLoach.: Designing
                                                           and Specifying Mobility within the Multiagent
                                                           Systems Engineering methodology. Special Track on


                    Ubiquitous Computing and Communication Journal
    Agents, Interactions, Mobility, and Systems (AIMS)
    at the 18th ACM Symposium on Applied Computing
    (SAC 2003). Melbourne, Florida, USA, 2003.
[17]       Tommy Thorn: Programming languages for
    mobile code. Rapport de recherche INRIA, N ° 3134,
    Mars, 1997.
[18]       R. Valk: Petri Nets as Token Objects: An
    Introduction to Elementary Object Nets. Applications
    and Theory of Petri Nets 1998, LNCS vol.1420, pp.1-
    25, Springer-Verlag, 1998.
[19]       F. Rosa Velardo, O. Marroqn Alonso and D.
    Frutos Escrig: Mobile Synchronizing Petri Nets: a
    choreographic approach for coordination in
    Ubiquitous Systems. In 1st Int. Workshop on Methods
    and Tools for Coordinating Concurrent, Distributed
    and Mobile Systems, MTCoord’05. ENTCS, No 150.
[20]       Fernando Rosa-Velardo:         Coding Mobile
    Synchronizing Petri Nets into Rewriting Logic. this
    paper is electronically published in Electronic Notes
    in     Theoretical     Computer      science     URL:
    www.elsevier.nl/locate/entcs.
[21]       Sutandiyo, W., Chhetri, M, B., Loke, S,W., and
    Krishnaswamy, S: mGaia: Extending the Gaia
    Methodology to Model Mobile Agent Systems.
    Accepted for publication as a poster in the Sixth
    International Conference on Enterprise Information
    Systems (ICEIS 2004), Porto, Portugal, April 14-17.
[22]       D.J. Wetherall, J. Guttag, and D.L.
    Tennenhouse: ANTS: A Toolkit for Building and
    Dynamically      Deploying      Network      Protocols.
    Technical     Report,     MIT,    1997,    in     Proc.
    OPENARCH’98.
[23]       M. Clavel, F.Durán, S.Eker, P.Lincoln,
    N.Marti-Oliet, J.Meseguer, and J. Quesada: Maude:
    specification and programming in rewriting logic.
    SRI         International,       Januray         1999,
    http://maude,.csl.sri.com.
[24]       J. Meseguer: Conditional rewriting logic as a
    unified model of concurrency. Theoretical Computer
    Science, 96 (1):73-155, 1992.
[25]       P.C.Ölveczky, J. Meseguer: Real-Time Maude
    : A tool for simulating and analyzing real-time and
    hybrid systems. In K. Futatsugi, editor, Third
    International Workshop on Rewriting Logic and its
    Applications, volume 36 of Electronic Notes in
    Theoretical Computer Science. Elsevier, 2000.
    http://www.elsevier.nl/locate.entcs/volume36.html.
[26]       Laïd Kahloul, Allaoua Chaoui: Temporal
    Labeled Reconfigurable Nets for Code Mobility
    Modeling. The International Workshop on
    Trustworthy Ubiquitous Computing (TwUC 2007)
    associated to the iiWAS2007 conference.
[27]       Laïd Kahloul, Allaoua Chaoui: Coloured
    reconfigurable nets for code mobility modeling. In
    the Proceedings of World Academy of Science,
    Engineering and Technology, Volume 25, November
    2007 with ISSN: 1307-6886. WASET-XXV
    International Conference Venice, Italy.




                       Ubiquitous Computing and Communication Journal

				
DOCUMENT INFO
Shared By:
Categories:
Tags: UbiCC, Journal
Stats:
views:20
posted:6/17/2010
language:English
pages:9
Description: UBICC, the Ubiquitous Computing and Communication Journal [ISSN 1992-8424], is an international scientific and educational organization dedicated to advancing the arts, sciences, and applications of information technology. With a world-wide membership, UBICC is a leading resource for computing professionals and students working in the various fields of Information Technology, and for interpreting the impact of information technology on society.
UbiCC Journal UbiCC Journal Ubiquitous Computing and Communication Journal www.ubicc.org
About UBICC, the Ubiquitous Computing and Communication Journal [ISSN 1992-8424], is an international scientific and educational organization dedicated to advancing the arts, sciences, and applications of information technology. With a world-wide membership, UBICC is a leading resource for computing professionals and students working in the various fields of Information Technology, and for interpreting the impact of information technology on society.