JP2007188384A - Method for managing object-oriented memory, analysis program, and nuclear reactor core property analysis program - Google Patents

Abstract

<P>PROBLEM TO BE SOLVED: To provide a method for managing an object-oriented memory where masking property aimed at by object orientation is not damaged, the number of storage devices can be reduced and processing speed is improved in a programming model of a high abstractness and a large scale using object-oriented language. <P>SOLUTION: In the method for managing the object-oriented memory, an array object in which a memory area where each object requires access for calculation is secured continuously is prepared. To each object, reference information for making the object access to the memory area for calculation is assigned by slicing the array object. Moreover, each object updates a part equivalent to the reference information of the array object on the basis of the reference information. <P>COPYRIGHT: (C)2007,JPO&INPIT

Description

  The present invention relates to an object-oriented memory management method, and more particularly to an object-oriented memory management method for abstracting and improving the efficiency of memory access for nuclear reactor core analysis.

  Large-scale science and technology calculations such as reactor core analysis require a large amount of primary storage, and the memory usage efficiency has a large impact on the scale and speed of the calculation system, which in turn increases the calculation accuracy. Influence. On the other hand, from the viewpoint of improving development efficiency in recent programming methodologies, an object-oriented approach is often used, but this method is a set of data and means corresponding to data such as means for manipulating the data. Therefore, it is common not to directly handle hardware-related parts such as memory management.

  In large-scale scientific and technological calculations, such as reactor core analysis, weather forecasts, and various simulation analyses, not only initial data such as reference data, initial values, and boundary values, but also intermediate results must be retained. There are many cases. In particular, a calculation that repeats a similar process many times, specifically, for example, first, calculate the stress and heat distribution by rough mesh division based on the boundary condition, and then use the calculation result to make a little more detailed. A program that calculates stress and heat distribution in mesh division a little in detail, then gradually reduces mesh division to calculate precise stress and heat distribution, etc. One month for each part of the mesh divided based on initial values Calculate the state after, and then calculate the state after two months using the calculation result, then repeat this procedure to calculate the state after one year and analyze the combustion of the reactor That is the case with programs.

  Therefore, when performing calculation and analysis using, for example, an object-oriented language such as C ++, a dynamic memory reservation function provided in the object-oriented language is used to store a specific memory area generally called a heap area. The data area is secured and assigned to the object. However, as long as a general dynamic memory allocation method (new, object generation method) is used, the location of the memory area at the time of allocation may change during program execution, so that necessary data continues. There is no guarantee that it will be taken from the memory area, and memory fragmentation may occur. These states are conceptually shown in FIG. In FIG. 1, 10 is an address of the base memory (indicated by addr), 11, 12, and 13 are addresses of each object in the heap area, and 21, 22, and 23 are each object (data to be operated, A set of implementation units (functions) that perform actual operations (corresponding to subroutines that actually analyze the neutron distribution and the like of the core in Fortran) 1, 2, and 3. The arrow indicates the address direction of the base memory (address numbers increase in order). The objects 1, 2, and 3 are assigned small heap area addresses 11, 12, and 13, respectively. As shown in FIG. 1, the addresses 11, 12, and 13 of each heap area are discontinuous areas, and the addresses are also discontinuous.

In addition, if the allocation and release of the memory area are repeated to hold intermediate results in repeated calculations, etc., the fragmentation of the memory is promoted, and as a result, file accesses can be performed with a large amount of I / O transactions in a small amount of data. It must be executed and is disadvantageous in terms of processing time.
As a countermeasure, it is often difficult for each object to have duplicate data from the hardware as well as the software aspects.

  Therefore, it is conceivable to devise a memory securing portion so that an array having one continuous large memory space is secured once and a part of the array is allocated to each object. That is, it is conceivable to assign reference information to a continuous memory area in which data is stored rather than having a data body in each object. FIG. 2 shows this state. In this figure, for each object 1, 2 and 3, there are addresses 11, 12, 13 which are consecutive in the address of the base memory, that is, addresses which are continuous areas (continuous heap areas) in the base memory. Further, information (pointers) 31 and 32 for referring to the assigned addresses 11, 12, and 13 for each of the objects 1, 2, and 3 (my new, creation of an object by unique management). , 33 are added.

  This eliminates the need for copying when the contents of this array are collectively written to a file. In addition, it is possible to collectively write out contents that are apparently held by a plurality of objects to a disk, or to automatically initialize a plurality of objects by reading the contents of a file. Specifically, when calculating and analyzing various conditions in the furnace, such as the degree of burnup of each fuel assembly in the furnace up to several months in advance, every month, Results of burnup, neutron distribution, density, etc. calculated by each object using the initial value of the month are written in order, and all calculations for each object for that month are completed, and the analysis for the next month is completed. When starting, the result of the month immediately before the end of the analysis already written in the base address is read to each object as an initial value.

  However, in this case, since memory management is a so-called “low level” operation and processing close to hardware, there is a risk of losing the concealment aimed at by object orientation. For example, if the memory space held by each object is duplicated for some reason, if one object rewrites its member variable (the field for holding the data in the object), the member variable of the other object It could also mean that it was changing.

  Specifically, in the above calculation example, the first month consisting of a large number of objects is calculated based on a given initial condition, and the calculation result is newly set as the initial condition, and the next When calculating one month (second month) of an object, in the calculation process for the first month, an object uses that object to calculate the next month based on the calculation result. If some data of the initial condition related to the calculation is rewritten (or updated), other objects that follow in the calculation process for the first month use the original initial condition. It may happen that it is impossible to calculate the parts and contents for the first month.

  However, in an actual large-scale calculation, objects are often associated with each other, and for example, iterative calculations usually have a large number of repetitions. On the other hand, programming models using object-oriented languages are highly abstract. As a result, careful attention is required to prevent this from occurring, and the burden on the programmer increases.

  For this reason, in a high-level and large-scale programming model using an object-oriented language, the object-oriented concealment is not impaired, the number of accesses to the memory is small, and less storage devices are required. It has been desired to develop an object-oriented memory management method that is excellent in calculation cost, processing speed, and the like.

The present invention has been made for the purpose of solving the above-mentioned problems. In order to minimize the memory securing operation, an object having concealment in contents is secured, and a memory is allocated to each object. When distributing, a subset object indicating the same memory as an object having concealment in content is distributed.
The invention of each claim will be described below.

The invention described in claim 1
An array object is created in which memory areas that each object needs to access at the time of calculation are continuously allocated,
For each object, reference information for the object to access the memory area at the time of calculation is assigned by slicing the array object,
Furthermore, each object updates a memory area corresponding to the reference information of the array object based on the reference information, and is an object-oriented memory management method.

According to the invention of this claim, each object is associated with the array object based on the reference information created by slicing (slicing) the array object in which memory areas that require access at the time of calculation are continuously secured. Update the part corresponding to the reference information. For this reason, in the calculation process using the object-oriented language, the concealment aimed at by the object orientation is not impaired, and the reference information held by other objects is not rewritten.
In addition, memory fragmentation is not promoted, so the number of accesses to the memory can be reduced, programming difficulties required for memory management can be eliminated, and fewer storage devices are required. , Calculation cost, maintainability, processing speed, etc. are also excellent.

The invention according to claim 2 is the object-oriented memory management method,
The reference information of the memory area secured by the array object is represented by m n-dimensional matrices,
In the object-oriented memory management method, the slicing is performed in units of reference information expressed by the n-dimensional matrix.

In the invention of this claim, conceptually, the allocation of the memory area to each calculation object is performed by slicing m pieces of reference information arranged in a straight line, and each sliced data is stored in the memory area. Is represented by an n-dimensional matrix, it becomes easy to avoid duplication of memory areas allocated to the respective calculation objects. Here, m (number of matrices) and n (dimensions) are appropriately optimized values depending on the number of calculation objects, mesh division, and the like, but both are positive integers.
In addition, when expressed in an n-dimensional matrix, it becomes easy to store and rewrite many types of data in units of rows and columns, and to create a program.
Note that expressing one-dimensional reference information and data in an n-dimensional matrix means, for example, that one-dimensional reference information and data are arranged in two columns by arranging 10 × 10 pieces of reference information and the like in 10 columns. It is created by appropriately dividing reference information and the like.

The invention according to claim 3 is the object-oriented memory management method,
An object-oriented memory, wherein the array object has a class definition unit, and data is input / output by accessing the memory area of each object under the action of the class definition unit It is a management method.

  In the invention of this claim, under the action of the adjustment processing for the memory distribution of the class definition section, the contents that are apparently held separately by a plurality of objects are collectively written to a disk, or the contents of a file are read and read Some objects are automatically initialized. For this reason, the number of accesses to the memory of each object is reduced in complex calculations, and the calculation time is shortened.

The invention according to claim 4
An analysis program that employs the object-oriented memory management method according to any one of claims 1 to 3.

In the invention of this claim, since the object-oriented memory management method according to any one of claims 1 to 3 is employed, an analysis program in which various objects repeatedly perform complicated repeated calculations. However, it is possible to save the memory itself necessary for the calculation, to facilitate the management of data input / output to / from the memory, and to reduce the time required for the memory access. As a result, reduction of processing time and reduction of processing cost are achieved.
Note that the link between the program that actually performs the analysis and the object that manages the reference information, that is, the reference information is created by slicing the array object that is secured so that the memory areas that require access at the time of calculation are continuous. For this purpose, for example, a public technique such as “Blitz ++” or “boost” is used.

Invention of Claim 5 is the said analysis program, Comprising:
The analysis program divides the analysis target into meshes, performs the same calculation for each mesh, and manages the data necessary for the calculation and the memory management for the calculation results using reference information expressed in m n dimensions An analysis program characterized in that the memory management is performed by the object-oriented memory management method according to any one of claims 1 to 3. is there.

  In the invention of this claim, since the analysis target is divided into meshes, the reference information expressed by a matrix corresponding to the mesh division is created, thereby accessing the storage area and managing the data. To improve efficiency.

Invention of Claim 6 is the said analysis program, Comprising:
This is an analysis program characterized by being a reactor core characteristic analysis program.

  Reactor core analysis programs use the vast amount of data to repeat the same calculation many times, and also frequently rewrite the calculation results. Therefore, if the invention of claim 4 or claim 5 is used, only data management is possible. It is ideal for creating, modifying and checking programs.

The invention described in claim 7
The reactor core is divided into three dimensions, the horizontal direction (two dimensions) and the vertical direction (one dimension), and various physical quantities as initial values are stored in each mesh, and those values are stored based on the stored initial values. A reactor core characteristic analysis program that calculates a change with time and further adopts the object-oriented memory management method according to any one of claims 1 to 3 at the time of the calculation,
The management of each mesh memory for the various physical quantities as the initial values and the calculated physical quantities over time is performed in a storage area determined by reference information represented by m n-dimensional matrices. It is a reactor core characteristic analysis program.

  The core analysis program for a nuclear reactor repeats the same calculation many times using a large amount of data, and also frequently rewrites the calculation result. Therefore, the object-oriented memory management method according to any one of claims 1 to 3 is used. In addition, the management of each mesh of the various physical quantities as the initial value and the calculated physical quantities for each time is performed in a storage area determined by reference information represented by m n-dimensional matrices. This makes it easy to create, modify, and check programs as well as managing programs.

The invention according to claim 8 is the above-mentioned nuclear reactor core characteristic analysis program,
For each mesh, there is a step of performing calculation using data stored in a storage area determined by the reference information represented by the n-dimensional matrix and storing the calculation result. It is a reactor core characteristic analysis program.

  The analysis is performed using data stored in a storage area determined by the reference information represented by the n-dimensional matrix for each mesh, and stores the calculation result. The features of the invention are most easily exhibited.

The invention according to claim 9 is the above-mentioned nuclear reactor core characteristic analysis program,
A reactor core characteristic analysis program characterized by having a step of repeatedly calculating each mesh.

  Since it is an iterative calculation, use and rewriting of data are also repeated. At this time, since the reference information of the memory area is created in an n-dimensional matrix, the features of the inventions of claims 7 and 8 are further exhibited.

In the present invention, in a high-level and large-scale programming model using an object-oriented language, memory is managed using a subset object that shares the same memory space as the original object. Efficient memory management is performed without losing the concealment.
For this reason, by losing the concealment property, various inconveniences such as one object rewriting data necessary for another object do not occur.
In addition, the amount of memory required for the calculation is small, and the access time to the memory is shortened, so that the calculation cost is reduced and the calculation speed is improved.
Further, since the subset object is used for memory management, it is not necessary to provide a complicated memory management mechanism in the calculation code, and as a result, the structure of the calculation code is simplified, which contributes to improvement in maintainability.

  In addition, the calculation of each part of the reactor core analysis program etc. is repeatedly performed for the mesh-divided items, etc. At this time, the use, rewriting, storing, etc. of various and many related data are performed on a large scale In a necessary analysis program, a continuous storage area is secured, and reference information of an allocated location for the storage area required by each calculation object is given as an n-dimensional matrix, so that the calculation speed is improved. Not only can the calculation cost be reduced, but also the creation of a program becomes easy.

  Hereinafter, the present invention will be described based on the best mode. In addition, this invention is not limited to the following embodiment. Various modifications can be made to the following embodiments within the same and equivalent scope as the present invention.

(Description of principle)
The principle of the object-oriented memory management method of this embodiment will be described with reference to the drawings. FIG. 3 is a diagram conceptually showing the distribution of the memory to the objects 21, 22 and 23. In FIG. 3, 40 is an array object, and 49 is a class definition section. The array object 40 manages a collection of memory areas that each of the objects 21, 22, and 23 should have, and each object 21, 22, and 23 has allocation reference information (Subset reference) corresponding to the memory area that they should have. The subset reference information 41, 42, 43 is assigned. For this reason, a large number of two-dimensional subset reference information is arranged one-dimensionally (overlaid) and held in the memory.
For this reason, each object 21, 22, 23 shares the same memory space as the array object 40 via its own subset reference information 41, 42, 43. Each of the objects 21, 22, and 23 has an execution unit (function) that performs an actual operation, but is not shown in FIG. 3 because it is obvious and complicated.

When the subset reference information 41, 42, 43 assigned to each object 21, 22, 23 is changed, the contents of the corresponding subset (main body) of the array object 40 are also changed. However, the contents of the subset reference information (and the main body) of other objects are protected.
Furthermore, the addresses of the memories corresponding to the subset reference information 41, 42, 43 do not overlap, and the distribution and control of the data that each object 21, 22, 23 writes to or reads from the memory is an array object. This is done in 40 class definition sections 49.

(If you have a large number of calculation objects)
Next, the state of the management method and file access method for each object when there are a large number of calculation objects will be described with reference to FIG. FIG. 4 is a diagram conceptually showing this state. In FIG. 4, reference numeral 40 denotes an array object that is a collection of information about memory areas that each of the objects 21, 22, and 23 should have, and reference numeral 44 denotes a memory area. The array object 40 is a one-dimensional array, and an object created by dividing the array object 40 by slicing (as a subset thereof) is given to each of the objects 21, 22, and 23 as reference information, and the memory area 44 is also the same. An area corresponding to the reference information is given to the object divided by slicing and created as reference information (subset). Therefore, the length is equal to the information about the memory area that each object 21, 22, 23 should have, and a memory area (continuous heap area) continuous to each object 21, 22, 23 is secured based on this information. Has been. Furthermore, since both the array object 40 and the memory area 44 are divided by slicing, no memory contention occurs in principle.

(Sample code)
The above operation concept will be described using the sample code shown in FIG. This code uses C ++ to secure a three-dimensional array object A of size (4, 3, 2), and changes the contents of A by the following two methods.
1. Explicitly change the contents of object A. This is shown at the top of FIG.
2. Retrieves reference information for a two-dimensional array of size (3, 2), which is a subelement of object A, places it in four block objects, and each block object is a content for the subarray of object A, which is an internal variable To change. This is shown at the bottom of FIG.

The upper sample code of FIG. 5 will be described below.
Lines 1 to 5 are initialized for a template library “blitz ++” in order to perform slicing.
Line 7 defines the REAL type, which is essentially an alias for float.
The 9th to 33rd lines are the definition part of the “block” object, which is 49 in FIG. 3 and is a part that defines the behavior of 21, 22, and 23.

In the 16th to 21st lines, the behavior of “Sr” in FIG. 3 is defined. This is a so-called constructor, which is a method for generating the object 21 and the like, and two of the division target object a (corresponding to 40 in FIG. 3) and information pos about the cut-out position are passed as arguments. Thus, for example, with respect to the generation of the object 21 in FIG. 3, the reference method for the reference information 41 (the object indicating the two-dimensional array in the array defined in the 12th line) owned by the 19th line. And reference information for a portion of 40 created by “a (pos, Range :: all (), Range :: all ())” is assigned to 41. As a result, the array of 41 becomes an incarnation of 40 partial arrays, and the memory space is shared.
The funcl method is defined in the 23rd to 32nd lines. While operating on the member variable array, a portion of another global object sharing the memory space is substantially changed.

The contents of the sample code at the bottom of FIG. 5 will be described.
The 36th to 61st lines are the test program main body. When an execution module compiled with this code is run, control is transferred to the 36th line first.
In the 38th line, a pointer to the three-dimensional array a is declared. In addition, a pointer to a pointer array to the block object is defined.
In the 41st line, a global array object a is defined. The size of each dimension is 4, 3, and 2, respectively. The first 4 is the length, and 3 and 2 are the lengths of each dimension of the 3 × 2 two-dimensional array. That is, four 3 × 2 two-dimensional arrays are secured.

In the 43rd to 50th lines, values are set for the three-dimensional array.
In line 51, the contents of the three-dimensional array (object) a are displayed.
The data structure is displayed in the 52nd line. This is shown from the line “Dump of...” To “is Storage Contiguous ()” in FIG.
In the 55th to 59th lines, a reference object corresponding to 21 in FIG. 3 is generated as slicing of the global array a. For this reason, the operation of the local variable 41 of each object by the b funcl method actually changes the corresponding part of 40.
In the 61st line, the side effect of the operation performed in the 55th to 59th lines {the effect of the operation other than obtaining the return value in the function (value display, etc.)} appears.

  FIG. 6 shows the execution result of the sample code shown in FIG. Said 1.2. In either case, the content of the object A is changed as a result. Then, the array a is substantially concealed, and the independence of each block object is ensured, and a merit on the program can be obtained. In the first six items, the information has been updated, but since it was the same value, it seems that there was no change on the surface.

(Application to core analysis code)
The above will be described by taking a reactor core analysis program as an example.
In the core analysis of a pressurized water reactor, in the XY (horizontal) direction, the width of the fuel lattice (about 1.26 cm) is about 300 × 300, and the Z (axis, vertical) direction is targeted for the 1/4 core. Is divided into 30 with a width of about 15 cm, that is, a (300, 300, 30) as a three-dimensional array. Then, physical quantities such as neutron flux, number density of each nuclide, burnup, fuel information, etc. are held for each mesh, and further, changes with time of these physical quantities are calculated.

Each object 21, 22, and 23 in FIG. 4 represents a unit (node) divided by a 1/4 aggregate unit in the core, and a calculation mesh is prepared therein and various data are held.
Since these data need to be recorded in a restart file separately supplied when each object 21, 22, 23 starts calculation, a part of memory fragments distributed in each object 21, 22, 23 Are prepared as subset reference information (subarray) 41 of the array object 40. For this purpose, the memory defined by the one-dimensional array is divided and embedded in the objects 21, 22, and 23. Thereby, the memory change in each object 21, 22, 23 is automatically reflected in the one-dimensional array in the array object 40.

In actual calculation, mesh division of a (300, 300, 30) as the three-dimensional array is managed as b (27000, 10, 10). That is, it is managed that there are 27000 (10, 10) two-dimensional arrays (30 each in the X, Y, and Z directions). That is, as shown by 40 in FIG. 4, a 2D array of (10, 10) is a 1D object array arranged in a one-dimensional manner (in one column), and the portion of (10, 10) corresponds to 41. To do.
As a result, in the calculation of each mesh, each object is calculated by referring to the data of the area (10, 10) given as the reference information, and the data of the area is rewritten. For this reason, it becomes more flexible than handling one huge container of information.

It is a figure which shows notionally a mode that the specific address (memory area | region) is ensured and allocated separately for each object, and also fragmentation of the memory has occurred as a result. It is a figure which shows notionally a mode that a series of large memory is ensured separately, and the reference information to the said memory area is allocated to each object. It is a figure which shows notionally a mode that it has an array object which has a class definition part which secured a series of large memory separately, and the reference information of an array object is allocated to each object. It is a figure which shows notionally the relationship between the reference information to the partial arrangement | sequence in each object, and the whole arrangement | sequence. It is a sample code as an embodiment of the present invention. It is an operation result of the sample code shown in FIG.

Explanation of symbols

10 Base memory address 11, 12, 13 Heap area address 21, 22, 23 Object 1, Same 2, Same 3
31, 32, 33 Reference information of each object 40 Array objects 41, 42, 43 Subset reference information in each object 44 Memory area 49 Class definition section

Claims (9)

An array object is created in which memory areas that each object needs to access at the time of calculation are continuously allocated,
For each object, reference information for the object to access the memory area at the time of calculation is assigned by slicing the array object,
Further, each object updates a memory area corresponding to the reference information of the array object based on the reference information. The reference information of the memory area secured by the array object is represented by m n-dimensional matrices,
The object-oriented memory management method according to claim 1, wherein the slicing is performed in units of reference information represented by the n-dimensional matrix.   2. The array object includes a class definition unit, and data is input / output by accessing the memory area of each object under the action of the class definition unit. The object-oriented memory management method according to claim 2.   4. An analysis program that employs the object-oriented memory management method according to claim 1.   The analysis program divides the analysis target into meshes, performs the same calculation for each mesh, and manages the data necessary for the calculation and the memory management for the calculation results using reference information expressed in m n dimensions 5. The memory area according to claim 4, wherein the memory management is performed by the object-oriented memory management method according to any one of claims 1 to 3. Analysis program described in 1.   6. The analysis program according to claim 4, wherein the analysis program is a reactor core characteristic analysis program. The reactor core is divided into three dimensions, the horizontal direction (two dimensions) and the vertical direction (one dimension), and various physical quantities as initial values are stored in each mesh, and those values are stored based on the stored initial values. A reactor core characteristic analysis program that calculates a change with time and further adopts the object-oriented memory management method according to any one of claims 1 to 3 at the time of the calculation,
The management of each mesh memory for the various physical quantities as the initial values and the calculated physical quantities over time is performed in a storage area determined by reference information represented by m n-dimensional matrices. Reactor core characteristics analysis program.   2. The method of performing calculation using data stored in a storage area determined by reference information represented by the n-dimensional matrix for each mesh, and storing a calculation result. 7. Reactor core characteristic analysis program according to 7. 9. The nuclear reactor core characteristic analysis program according to claim 8, further comprising a step of repeatedly calculating each mesh.

Images