Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
1/8
Organization (S): EDF/IMA/MN
Handbook of Descriptif Informatique
D2.06 booklet:
D2.06.01 document
Use of JEVEUX
Summary:
It is a question here of indicating some concepts of operation of the manager of memory JEVEUX in order to
to specify the use of the routines “user”, to indicate the routines the best appropriate ones to certain actions and
to announce the difficulties of use. One presents here the rules of use in italic in each paragraph.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
2/8
Contents
1 Use of the bases .............................................................................................................................. 3
2 Accesses per name .................................................................................................................................. 3
3 Accesses to the segments of values ........................................................................................................ 4
4 Initialization of the values .................................................................................................................... 5
5 Release of the segments of values and concept of mark .................................................................. 5
6 Backups .................................................................................................................................... 5
7 the allowance of a great segment of values ....................................................................................... 6
8 Detection of crushings report ................................................................................................ 6
9 To increase a vector .......................................................................................................................... 7
10 the recopy of the objects ...................................................................................................................... 7
11 routines working on groups of objects ............................................................................. 8
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
3/8
1
Use of the bases
The simple objects can be created by routines JECREO and WKVECT, the collections by the routine
JECREC.
WKVECT makes it possible to connect three calls JECREO, JEECRA and JEVEUO for an object of vector kind.
The basic concept makes it possible to associate the various objects a file backed up or not at the end of the work.
objects to be preserved at the end of the work will be created on basis GLOBALE associated with the class G. Cette bases
allows to preserve the structures of data and to carry out continuations.
The objects of work will be created on basis VOLATILE associated with the class V. Cette base is destroyed at the end
work. By convention, one will use the characters & & at the beginning of the name of any object associated with this base.
Base LOCALE associated with the class L is reserved for Superviseur.
It is pointed out that it is not possible to have objects of identical name on different bases.
routine I…. do not have among their arguments the name of the class and the scan for the noun is carried out
in the whole of the repertories associated with the various open bases.
base GLOBALE
name of class G
preserved objects
base VOLATILE
name of class V
temporary objects
base LOCALE
name of class L
reserved for Superviseur
2
Access by name
The access to the objects managed by JEVEUX is carried out using the name. One uses a function of coding which
provides starting from the name and various parameters a key of access (an entirety), this key allows then
to reach the various attributes. The access by name is relatively expensive (decoding of characters, management
of collision, etc…) also one in a variable preserves the last name (of simple object, collection and object
of collection) and the identifier (obtained starting from the key) associated, to avoid a new call to the function of
coding.
Note:
It is thus recommended to carry out all the request for the same object JEVEUX in way
sequential in order to profit from this possibility.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
4/8
3
Access to the segments of values
Routines WKVECT and JEVEUO return to the user a relative address in one of tables ZR, ZI,
Will ZC, or ZK, (one note Z thereafter? one of these variables FORTRAN). This address is valid as long as there is not
have release.
The concept of access in writing or reading makes it possible to avoid systematic unloading on disc of
segment of values and limit thus the number of the inputs/outputs on disc. Objects reached in reading
will not be backed up on disc at the time of the release. The call to WKVECT carries out a request in
writing.
A segment of values could be reached in writing then released, the manager then preserves it in memory
and its unloading differs on disc at the time of a forthcoming search of place. A new access in reading
return the address of the segment déchargeable, a modification of the contents can thus take place without the knowledge of
the user if this last does affect the contents of table Z? with the address indicated.
Regulate use:
The user, when it carries out an access in reading, should not modify the contents of the table
Z? with the address provided at the time of the request and must avoid passing it in argument of under
program it would not have the whole control.
Do the calls to routine JEVEUO return an address compared to a variable Z? of the same type as the object
JEVEUX (this address is measured in the length of the type). The standardized commun run must appear in all
unit of program carrying out this type of call.
INTEGER
ZI
COMMON/IVARJE/
ZI (1)
REAL * 8
ZR
COMMON/RVARJE/
ZR (1)
COMPLEX * 16
ZC
COMMON/CVARJE/
ZC (1)
LOGICAL
ZL
COMMON/LVARJE/
ZL (1)
CHARACTER * 8
ZK8
CHARACTER * 16
ZK16
CHARACTER * 24
ZK24
CHARACTER * 32
ZK32
CHARACTER * 80
ZK80
COMMON/KVARJE/
ZK8 (1), ZK16 (1), ZK24 (1), ZK32 (1), ZK80 (1)
Note:
Not to modify the noun of the variables of the commun run of reference.
The access to a segment of values is carried out in the following way: if JTAB indicates the address returned by
routine JEVEUO for an object of vector kind and type I, KTAB that for an object of the type C (complex):
ZI (JTAB)
is the first value of a vector of entireties,
ZI (JTAB + I - 1)
is Iéme value of a vector of entireties,
ZC (KTAB + I - 1)
is Iéme value of a vector of complexes.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
5/8
4
Initialization of the values
At the time of the call with JEVEUO or WKVECT the manager of memory carries out a search for place in
main memory. If the object does not have an image on disc (i.e. at the time of its first access in
writing), the segment of value is initialized according to the type of the object: 0. for realities, (0., 0.) for
complexes, 0 for the entireties, ''(white) for the characters.
Regulate use:
It is useless to carry out a loop of initialization before the first use of the segment of
values.
5
Release of the segments of values and concept of mark
If nothing is done (not call to JELIBE), the segments of values brought back in memory remain there and that can
to lead quickly to its saturation. On another side, if one releases an object without taking precautions (one
mark), one is likely to return invalid the address of an object requested upstream of the programming. One
systematic solution with this problem is not adopted yet today.
What is currently made (and which could be called into question):
· few objects (the large ones) are released what makes it possible to make sure that the releases are not
dangerous (good knowledge of the use of these objects);
· one uses the marks to release the objects.
The rules of use concerning this problem will be soon selected. While waiting:
Regulate use:
Not to release the objects systematically.
6 Backups
Routine JESAUV makes it possible in theory to protect the objects which one has just created (to avoid rewriting them
contents). In practice, this routine is almost never used. For the homogeneity of the code it us
seem that a rule should be selected: to save (or not) all the concepts. This decision was not yet
catch.
Regulate use:
Not to use JESAUV and JEDELI.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
6/8
7
The allowance of a great segment of values
A lack of place in the space managed by JEVEUX led to the brutal stop of the program (error message
according to: <S> <JJALLS02> FERMETURE DES BASES SUR ERREUR JEVEUX), only concepts created by
the preceding operators are preserved in base GLOBALE. It is possible to avoid this type of problem
by taking the precaution to call upon routine JEDISP in order to obtain the high limits of size in
the order descending of N zones of space available in memory (N being an entirety provided by the user).
Regulate use:
This call must be reserved for the allowance of very large objects in portions of
significant programming (for example solveurs).
Indeed the search of the storage areas requires a complete course of the chaining of the segments of
value and can appear expensive.
8
Detection of crushings report
JEVEUX dynamically manages a zone sequential memory whose size is determined by the parameter
memory defined in the completion of the work. The various segments of values associated with the objects are deposited
in this zone ones behind the others. Each segment of values is framed by 4 entireties in front of and 4
behind. These entireties make it possible to define a chaining before and a back chaining, to store the state and it
statute, the identifier and the class as well as a shift to manage the types of length higher than the unit
of addressing.
The crushing of the entireties located around the segment causes the rupture of the chaining and the loss of the identity of
the object associated with the segment with values. Such a crushing is generally detected at the time of one
search for place in memory (at the moment when the chaining is traversed) and not at the time of the overflow.
It results in one of the following error messages:
<S> <JJLIRS> <ECRASEMENT AMONT POSSIBLE ADRESSE> nnnn
In this case one crushed one of the entireties located in front of the segment of values.
<S> <JJLIRS> <ECRASEMENT AVAL POSSIBLE ADRESSE> nnnn
In this case one crushed one of the entireties located behind the segment of values.
Regulate use:
The developer has routine JXVERI then to instrument its code.
This routine checks the integrity of the chaining and can announce the frangible joint. It detects in more one
incursion out of the zone licit memory. It is possible to implement at less expenses in
order DEBUT or POURSUITE the call to this subroutine before each command, which allows
to determine which command carries out crushing. The developer will be able then, by instrumenting them
routines associated with the command, to proceed by dichotomy to determine the routine or the instructions
erroneous.
Crushing can also be less important and affect only one word in front of or behind the segment of values
without breaking the chaining, it is the case when one makes an error of index in table Z?. Contents of
the use or of the statute of the segment of value is then affected, this information can be obtained while consulting
the result of the impressions of the memory division by routine JEIMPM.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
7/8
9
To increase a vector
Regulate use:
The user has routine JUVECA to increase a simple object of vector kind.
It is a surcouche written starting from the routines user JEVEUX. It builds a temporary object and destroys
the original after recopy. One obtains the new relative address in return among the arguments. These various
operations can be rather expensive, it is thus preferable to minimize the number of calls for one
even vector and rather to double the size that to increase it progressively. Attention, this routine destroys
mark associated with the initial object and assigns the current mark to the new object.
10
The recopy of the objects
It is possible to recopy objects JEVEUX on the same basis or from one base to another. The recopy of
simple objects does not pose a particular problem, on the other hand it is more delicate to handle collections.
A collection can be pressed on an external repertory of names or an external pointer length. These
simple objects must be created and partly managed independently (for example their destruction must be
explicit). Their name can thus be without relationship with the name of the collection.
Two cases are possible:
· the recopy is carried out on different bases: the external pointers will be duplicated and
will become internal pointers with the collection,
· the recopy is carried out on the same basis: the external pointers can be preserved or
well it are duplicated and become internal.
If the receptacle is already existing, it is destroyed before recopy.
Regulate use:
To use JEDUPO or JEDUPC - not to use COPISD, COPIOB or COPIOC.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A
Code_Aster ®
Version
3.0
Titrate:
Use of JEVEUX
Date:
28/04/98
Author (S):
J.P. LEFEBVRE
Key:
D2.06.01-A
Page:
8/8
11
Routines working on groups of objects
The organization of the structures of data of Aster rests mainly on the names of the objects. One
handle within the code of the “concepts” built starting from a name provided by the user like result of
commands. It thus appeared convenient to be able to handle group of objects while providing under
character string, which is required in the names of all the objects present in the repertories.
Routines JELIBC, JEDETC and JEDUPC apply to lists of objects. They allow, in the order, of
to release, to destroy and duplicate the objects of these lists.
These routines offer more flexibility to the developer to manage the objects (structures of data).
Note:
It is little recommended to use them in the subroutines of low level, the cost of
seek using the under-chain being able to affect the performances appreciably.
Handbook of Descriptif Informatique
D2.06 booklet:
HI-75/95/009 Ind A