EP0456275A2 - A static memory allocation system - Google Patents

A static memory allocation system Download PDF

Info

Publication number
EP0456275A2
EP0456275A2 EP19910107762 EP91107762A EP0456275A2 EP 0456275 A2 EP0456275 A2 EP 0456275A2 EP 19910107762 EP19910107762 EP 19910107762 EP 91107762 A EP91107762 A EP 91107762A EP 0456275 A2 EP0456275 A2 EP 0456275A2
Authority
EP
Grant status
Application
Patent type
Prior art keywords
memory
program
volume
allocation system
system according
Prior art date
Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
Withdrawn
Application number
EP19910107762
Other languages
German (de)
French (fr)
Other versions
EP0456275A3 (en )
Inventor
Masayuki Kogure
Current Assignee (The listed assignees may be inaccurate. Google has not performed a legal analysis and makes no representation or warranty as to the accuracy of the list.)
Fujitsu Ltd
Original Assignee
Fujitsu Ltd
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date

Links

Images

Classifications

    • GPHYSICS
    • G06COMPUTING; CALCULATING; COUNTING
    • G06FELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00Arrangements for program control, e.g. control units
    • G06F9/06Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44Arrangements for executing specific programs
    • G06F9/445Program loading or initiating

Abstract

A memory allocation system is made up of a unit for storing the information about the memory volume required at the time of initializing an executable program in the control information of the file for storing the program by obtaining the necessary memory volume when the program is translated, assembled or compiled, a unit for reading the information about the memory volume required at the time of initializing the program stored in the control information of the file, when the execution format program is loaded, a unit for statically allocating a memory commensurate with the read memory volume; and a unit for dynamically allocating a memory, when the memory availability is deficient for executing the program.

Description

    Background of the Invention
  • This invention pertains to a system for statically allocating a memory for use in a computer system capable of efficiently allocating a memory necessary for executing FORTRAN programs, etc.
  • A super computer for high speed program execution using a pipeline processing or parallel processing requires that a program and the entire data referred to by the program be stored in its memory during the program execution. An efficient memory allocation technique is therefore sought.
  • Description of the Related Art
  • When a user program for scientific or technological calculations is run, if the memory for storing the program and the necessary data are deficient, it is necessary to interrupt the operation of other programs being executed to make additional memory available by swapping out the interrupted program onto an external memory device.
  • However, the volume of data handled by a super computer is generally huge and an overhead caused by the swapping is more severe than that caused by a general-purpose computer. Also, since a super computer is expected to provide high speed performance, the overhead caused by the swapping must be avoided in every way possible.
  • A static memory allocation method is effective in preventing the overhead caused by the swapping, which is defined as a method whereby the maximum memory volume deemed necessary for executing a program to be run is allocated in advance and the memory is kept allocated until the program execution is ended.
  • Since this method allows programs to be executed with the necessary memory already allocated beforehand, no memory deficiency occurs while the programs are being executed, and an overhead produced by swapping can be avoided. However, since the memory is kept allocated, their usage efficiencies are lowered.
  • On the other hand, a dynamic memory allocation method is defined as a method whereby requested memory is allocated only when a memory request is made, thus generally creating no idle memories. Yet, since overhead produced by a swapping cannot be avoided when multiple programs are run concurrently, it is not effective to apply this method to a super computer system.
  • Figure 1 shows an example of the prior art for static memory allocation.
  • Generally, a user specifies the memory volume kept allocated by job control statements 21 using a conventional static memory allocation method.
  • The following is a description of the memory allocation method of a prior art by referring to the steps [1] through [6] shown in Figure 1.
    • [1] A job management section 22 interprets the specification on the volume of memory allocation described in the job control statement 21.
    • [2] The job management section 22 notifies a memory management section 15 of the interpreted volume of memory allocation.
    • [3] The memory management section 15 allocates the specified volume of memory 23.
    • [4] The memory management section 15 notifies the job management section 22 of the completion of allocating the memory 23.
    • [5] The job management section 22 calls up a loader 14 when the environment for executing the job is complete.
    • [6] The loader 14 loads an executable program 13 into the memory 23.
  • After the loading, the program is initialized and the program execution begins.
  • A user needs to precisely estimate the memory volume necessary for program execution for an efficient memory allocation, when he utilizes the conventional static memory allocation method.
  • However, it is difficult to correctly estimate the memory volume necessary for the program execution. Because the precise estimation is difficult, in order to avoid abnormally terminating a program execution because of a memory deficiency, the user often specifies a memory volume larger than necessary. Therefore, less of the memory allocated for the program are actually used and the memory usage efficiency tends to be lowered.
  • Figure 2 shows an example of a time series change in the memory volume allocated for a program using the conventional static memory allocation.
  • In Figure 2, the part with slashes indicates the actually used memory volume. However, the memory volume specified by a user is kept allocated to the program from where the program execution is requested until the program execution is completed irrespective of the actually used volume. This causes an increase in the volume of idle memory, which could have been allocated for other programs running concurrently, resulting in a decrease in the number of jobs which can be executed simultaneously.
  • Summary of the Invention
  • This invention aims at reducing the users' workloads where estimating the memory volume necessary for program execution and preventing memory wastage by unnecessary memory allocation.
  • This invention pertains to a system for statically allocating a memory for use in a computer system capable of efficiently allocating a memory necessary for executing FORTRAN programs, etc.
  • This invention configures a system made up of a unit for storing the information on the memory volume necessary for initializing an execution format program in the management information section of the file for storing the program by obtaining the necessary memory volume when the program is translated, assembled or compiled, a unit for reading the information about the memory volume required at the time of initializing the program stored in the management information section of the file, when the execution format program is loaded, a unit for statically allocating a memory commensurate with the read memory volume; and a unit for dynamically allocating a memory, when the memory is deficient for the program execution.
  • Brief Description of the Drawings
    • Figure 1 shows an example of the prior art for static memory allocation;
    • Figure 2 shows an exemplary state of memory allocation according to the prior art;
    • Figure 3 is a block diagram of a principle of this invention;
    • Figure 4 shows a block diagram of an embodiment of the present invention;
    • Figure 5 shows an exemplary state of memory allocation in the embodiment of this invention;
    • Figure 6 is a flowchart illustrating the operation of a linkage editor;
    • Figure 7 is a flowchart illustrating the operation of a loader; and
    • Figures 8A and 8B are flowcharts illustrating the operation of a program executor.
    Description of the Preferred Embodiment
  • Figure 3 is a block diagram designating a principle of the present invention.
  • In Figure 3, 10 is an object program previously translated from a source program into a machine language command level, 11 is an linkage editor for creating an executable program by compiling and linking a program, 12 is a management information section for storing management information on an executable program, 13 is an executable program, 14 is a loader for loading an executable program into a memory, 15 is a memory management section for allocating a memory in response to a memory allocation request by controlling an actual memory not being used, and 16 is a program executor for executing an executable program.
  • This invention assumes that the information management section 12 of a file storing the executable program 13 has storage spaces for a memory volume required at a program initialization.
  • In a processing step P1, while a compiler and the linkage editor 11 translates, assembles or compiles a program, the management information section 12 stores the information about a memory volume necessary for initializing the program, which takes account of the volumes of memory to be used by the program.
  • In a processing step P2, the loader 14 reads the information on the memory volume necessary for initializing the program stored in the management information section 12 and notifies the memory management section 15 of the memory volume, when it loads the executable program 13.
  • In a processing step P3, the memory management section 15 statically allocates the memory according to the notified memory volume.
  • In a processing step P4, if the program executor 16 encounters a memory deficiency while it executes a program, the program executor 16 requests the memory management section 15 to allocate the deficiency in memory volume and the memory management section 15 dynamically allocates the requested memory.
  • A feature of this invention resides in a combined use of a static memory allocation based on program information notified from a compiler and a linkage editor and a dynamic memory allocation when the statically allocated memory is deficient, which eliminates the need for having a user specify the memory volume to be used. To be specific, the memory allocated are defined here as a memory space, where an actual memory corresponds on a one-to-one basis with a virtual memory.
  • In other words, the prior art requires that a user specifies the memory volume to be allocated by a job control statement, and a job management section requests the memory management section 15 to allocate a memory, when the job management section receives a request for executing a program.
  • On the other hand, this invention enables the loader 14 to request an allocation of necessary memory volume to the memory management section 15 immediately before it loads a program, based on the program information set in the management information section 12.
  • If a memory turns out to be deficient during a program execution, the prior art method of statically allocating a memory only causes an abnormal termination of the program execution, but the method of this invention prevents such an abnormal termination, because it also allocates a memory dynamically.
  • There is a risk that a dynamic memory allocation causes an overhead due to a swapping. But for the following reasons, memory deficiency during a program execution is considered rare, and an overhead due to a swapping is not much of a problem.
    • (a) Most programs a super computer system runs are written in FORTRAN.
    • (b) FORTRAN programs have little change in memory usage after their initialization is completed.
  • For the above reasons (a) and (b), few programs a super computer runs substantially change their memory usage. Therefore, the additional use of dynamic memory allocation seldom causes an overhead because of a memory competition.
  • Figure 4 shows an exemplary block diagram of an embodiment of this invention. Figure 5 shows an exemplary state of memory allocation in the embodiment of this invention.
  • The actions of the static memory allocation according to an embodiment of this invention are explained by referring to [1] through [8] shown in Figure 4.
    • [1] A compiler 20 and the linkage editor 11 obtain the memory volume necessary for initializing a program and stores the information in the management information section 12 before a translation, an assembly or a compilation.
    • [2] The job control statements 22 requests a program execution to the job management section 22. The job control statements 21 do not have to specify the volume of memory allocation.
    • [3] The job management section 22 interprets the job control statements 21 and sets up an environment for program execution except for the memory allocation. After the execution environment is complete, the job management section 22 requests a loading by the loader 14.
    • [4] The loader 14 reads the information on the memory volume required at the program initialization written in the management information section 12 of the file in the executable program 13.
    • [5] The loader 14 notifies the memory management section 15 of the information on the read memory volume.
    • [6] The memory management section 15 allocates the memory according to the necessary memory volume based on the notification from the loader 14.
    • [7] The memory management section 15 notifies the loader 14 of the completion of the memory allocation.
    • [8] The loader 14 reads the executable program 13 and loads it into the allocated memory.
  • As described above, a memory is allocated immediately before the loading of the programs, which are then initialized and their executions begin.
  • Figure 5 shows an exemplary time series change of the volume of memory allocation for a program.
  • The job management section 22 does not allocate a memory, when a program execution is requested. Instead, it allocates a memory in a batch according to the memory volume required at a program initialization, when the program is loaded. "a" shown in Figure 5 indicates the size of the loaded executable program.
  • Upon program initialization, the necessary data space is in a state of being used. "b" shown in Figure 5 corresponds to the size of the data space.
  • After the program execution starts, if a memory is deficient, an additional memory is dynamically allocated. However, cases requiring a swapping operation in a dynamic memory allocation are rare.
  • Figure 6 is a flowchart illustrating the operation of a linkage editor.
  • After the linkage editor begins its processes, it creates an executable program from an object program. Then, it calculates the memory volume acquired at program initialization. Finally, it stores the size of the executable program as "the memory volume required at program initialization" in the file management information section of the executable program, before it ends its processes.
  • Figure 7 is a flowchart illustrating the operation of a loader.
  • After the loader begins its processes, it reads the file's management information section of the executable program. Next, it notifies the memory management section of "the memory volume required at program initialization in the information read from the file's management information section. Then, it waits for the notification from the memory management section regarding the completion of the memory acquisition. Finally, it loads the execution format program, before it ends its processes.
  • Figures 8A shows a flowchart illustrating the operation of a program executor.
  • After the program executor begins its processes, it initializes a program and starts executing the program. If the memory is deficient while it executes the program, it interrupts the program execution, notifies the memory management section of the deficient memory volume, waits for the notification from the memory management section regarding the completion of the memory acquisition, and resumes executing the program. Unless the memory is deficient, it continues the program execution. When the program execution is completed, it requests the memory management section to release the memory, before it ends its processes.
  • More specifically, the memory deficiency is diagnosed by program error detection as shown in Figure 8B, and the volume of memory to be re-allocated is calculated from the memory volume required at the occurrence of an error. Namely, the volume of the memory acquisition is obtained as the difference between the requested volume of memory and the available empty memory volume.
  • As described above this invention does not require that a user precisely estimate the memory volume necessary for program execution. Since a memory is not occupied more than necessary, it is used efficiently, and its throughput is increased. Since the overhead does not increase, the high speed performance, which is a feature of a super computer system, is not hindered. Since the memory is allocated immediately before a program is loaded, rather than when the program execution is requested, the time period during which a memory is allocated becomes shorter.

Claims (14)

  1. A static memory allocation system for use in a computer system allocating a necessary memory for executing programs, said static memory allocation system comprising:
       a linkage editor means for storing the information about the memory volume required at the time of initializing an executable program in the management information section of the file for storing said program by obtaining said necessary memory volume when said program is translated, assembled or compiled;
       a loader means for automatically loading an executable program on said allocated memory and for reading said information about said memory volume required at the time of initializing said program stored in said management information section of said file, when said executable program is loaded; and
       a memory management section means for statically allocating a memory commensurate with said read memory volume.
  2. The static memory allocation system according to claim 1, further comprising:
       a program executor means for dynamically allocating a memory, when said statically allocated memory is deficient for executing said program.
  3. The static memory allocation system according to any preceding claim, wherein:
       said statically allocated memory required at program initialization is determined by the composite size of said executable program obtained at the time of the program initialization and the program work area acquired at the time of the program initialization.
  4. The static memory allocation system according to any preceding claim, wherein:
       the program work area obtained at the time of initializing said program is determined by the description and definition of said program.
  5. The static memory allocation system according to claim 2, wherein:
       the size of said executable program is determined by the result of translation, assembly or compilation.
  6. The static memory allocation system according to any preceding claim, wherein:
       that said memory is deficient for executing said program is detected when the current address reaches the final address of said allocated memory volume required at the time of initializing said program stored in said management information section of said file.
  7. The static memory allocation system according to any preceding claim, wherein:
       in dynamically allocating a memory, any empty spaces of said statically allocated memory are used for making up the deficiency in executing said program, and the remaining deficiency is made up through a swapping to a disk.
  8. The static memory allocation system according to any preceding claim, wherein:
       said program is written in FORTRAN.
  9. The static memory allocation system according to any or several of the preceding claims, wherein:
       said linkage editor means, after beginning its processes,
       creates said executable program from an object program;
       calculates said memory volume acquired at program initialization; and
       stores the size of said executable program as the memory volume required at program initialization in said management information section of said file in said executable program, before ending its processes.
  10. The static memory allocation system according to any or several of the preceding claims, wherein:
       said loader means, after beginning its processes,
       reads said management information section of said file in said executable program;
       notifies said memory management section means of the memory volume required at the program initialization in the information read from said management information section of said file;
       waits for the notification from said memory management section means regarding the completion of the memory acquisition; and
       loads said execution format program, before ending its processes.
  11. The static memory allocation system according to any preceding claim, wherein:
       said program executor means, after beginning its processes,
       initializes and starts executing said program;
       in case of a memory deficiency during the program execution, interrupts the program execution, notifies the memory management section of the deficient memory volume, waits for the notification from the memory management section regarding the completion of the memory acquisition, and resumes executing the program; or,
       otherwise, continues the program execution:
       upon completion of the program execution, requests the memory management section to release memories, before ending its processes.
  12. The static memory allocation system according to claim 11, wherein:
       said memory deficiency is diagnosed by a program error detection; and
       the volume of said memory acquisition is obtained as the difference between the additional memory volume requested and the available empty memory volume.
  13. A static memory allocation method for use in a computer system allocating necessary memories for executing programs, said static memory allocation method comprising:
       a step for storing the information on the memory volume necessary for initializing an executable program in the management information section of the file for storing said program by obtaining said necessary memory volume when said program is translated, assembled or compiled;
       a step for automatically loading an executable program on said allocated memories and for reading said information on said memory volume required at program initialization stored in said management information section of said file, when said executable program is loaded.
       a step for statically allocating a memory commensurate with said read memory volume.
  14. The static memory allocation method according to claim 13, further comprising:
       a step for dynamically allocating a memory, when said statically allocated memory is deficient for executing said program.
EP19910107762 1990-05-11 1991-05-13 A static memory allocation system Withdrawn EP0456275A3 (en)

Priority Applications (2)

Application Number Priority Date Filing Date Title
JP12175790A JPH0418638A (en) 1990-05-11 1990-05-11 Static memory allocation processing method
JP121757/90 1990-05-11

Publications (2)

Publication Number Publication Date
EP0456275A2 true true EP0456275A2 (en) 1991-11-13
EP0456275A3 true EP0456275A3 (en) 1993-07-21

Family

ID=14819135

Family Applications (1)

Application Number Title Priority Date Filing Date
EP19910107762 Withdrawn EP0456275A3 (en) 1990-05-11 1991-05-13 A static memory allocation system

Country Status (3)

Country Link
US (1) US5247674A (en)
EP (1) EP0456275A3 (en)
JP (1) JPH0418638A (en)

Cited By (7)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0590645A1 (en) * 1992-09-30 1994-04-06 Microsoft Corporation Method and system for reducing memory allocation requests
WO1995022104A1 (en) * 1994-02-14 1995-08-17 Ni-Tech Pty. Limited Use of multiple applications and allocation of memory or other resources in a gui environment
GB2301210A (en) * 1994-02-14 1996-11-27 Ni Tech Pty Limited Use of multiple applications and allocation of memory or other resources in a GUI environment
US7401199B2 (en) * 2006-06-28 2008-07-15 Motorola, Inc Method and system for allocating memory to an electronic device
CN100539713C (en) 2004-08-31 2009-09-09 华为技术有限公司 Method for memorying data flow in single-board
US20100070974A1 (en) * 2008-09-17 2010-03-18 Canon Kabushiki Kaisha Support apparatus for information processing apparatus, support method and computer program
WO2018050528A1 (en) * 2016-09-16 2018-03-22 Siemens Rail Automation Holdings Limited Statically determining a program memory requirements

Families Citing this family (31)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
CA2102883A1 (en) * 1993-02-26 1994-08-27 James W. Arendt System and method for lazy loading of shared libraries
JP2550864B2 (en) * 1993-05-31 1996-11-06 日本電気株式会社 Distributed control method and apparatus in the job execution
DE4334313A1 (en) * 1993-10-08 1995-04-13 Sel Alcatel Ag A method for managing a speech memory and device therefor
JPH07262079A (en) * 1994-03-16 1995-10-13 Fujitsu Ltd Buffer reallotment system
JPH08195764A (en) * 1994-11-15 1996-07-30 Ricoh Co Ltd Lan interface device
US5897662A (en) * 1995-08-18 1999-04-27 International Business Machines Corporation Pseudo-random address generation mechanism that reduces address translation time
US5930337A (en) * 1997-02-04 1999-07-27 Lucent Technologies Inc. Dynamic message-mailbox size variation
US6865734B2 (en) * 1997-10-06 2005-03-08 Sun Microsystems, Inc. Method and apparatus for performing byte-code optimization during pauses
US6230247B1 (en) * 1997-10-29 2001-05-08 International Business Machines Corporation Method and apparatus for adaptive storage space allocation
US6065130A (en) * 1997-12-01 2000-05-16 Telefonaktiebolaget Lm Ericsson Implementing counters in a system with limited primary memory
US6968438B1 (en) * 1999-09-20 2005-11-22 Texas Instruments Incorporated Application programming interface with inverted memory protocol for embedded software systems
US6546477B1 (en) 1999-09-20 2003-04-08 Texas Instruments Incorporated Memory management in embedded systems with dynamic object instantiation
US6665743B2 (en) * 2001-04-18 2003-12-16 International Business Machines Corporation Method, system, and program for initializing a storage space
US7212306B2 (en) * 2001-08-31 2007-05-01 Sharp Laboratories Of America, Inc. System and method for allocating random access memory in a multifunction peripheral device
US6954768B2 (en) * 2002-08-29 2005-10-11 International Business Machines Corporation Method, system, and article of manufacture for managing storage pools
US6985916B2 (en) * 2002-08-29 2006-01-10 International Business Machines Corporation Method, system, and article of manufacture for returning physical volumes
US7673304B2 (en) * 2003-02-18 2010-03-02 Microsoft Corporation Multithreaded kernel for graphics processing unit
US7444637B2 (en) * 2003-02-18 2008-10-28 Microsoft Corporation Systems and methods for scheduling coprocessor resources in a computing system
US7421694B2 (en) * 2003-02-18 2008-09-02 Microsoft Corporation Systems and methods for enhancing performance of a coprocessor
US6947051B2 (en) * 2003-02-18 2005-09-20 Microsoft Corporation Video memory management
US7331037B2 (en) * 2004-08-12 2008-02-12 National Instruments Corporation Static memory allocation in a graphical programming system
US8051268B2 (en) * 2005-07-29 2011-11-01 Panasonic Corporation Memory controller, nonvolatile storage device, nonvolatile storage system, and nonvolatile memory address management method
US7991962B2 (en) * 2007-12-10 2011-08-02 International Business Machines Corporation System and method of using threads and thread-local storage
US8316357B2 (en) * 2008-09-03 2012-11-20 Microsoft Corporation Type descriptor management for frozen objects
US9384711B2 (en) 2012-02-15 2016-07-05 Microsoft Technology Licensing, Llc Speculative render ahead and caching in multiple passes
US9235925B2 (en) * 2012-05-31 2016-01-12 Microsoft Technology Licensing, Llc Virtual surface rendering
US9230517B2 (en) 2012-05-31 2016-01-05 Microsoft Technology Licensing, Llc Virtual surface gutters
US9286122B2 (en) * 2012-05-31 2016-03-15 Microsoft Technology Licensing, Llc Display techniques using virtual surface allocation
US9177533B2 (en) 2012-05-31 2015-11-03 Microsoft Technology Licensing, Llc Virtual surface compaction
US8813018B1 (en) 2012-10-05 2014-08-19 Altera Corporation Method and apparatus for automatically configuring memory size
US9307007B2 (en) 2013-06-14 2016-04-05 Microsoft Technology Licensing, Llc Content pre-render and pre-fetch techniques

Family Cites Families (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0108346B1 (en) * 1982-11-04 1989-07-05 BULL HN INFORMATION SYSTEMS ITALIA S.p.A. Memory reconfiguration method in a data processing system
US4989137A (en) * 1984-07-12 1991-01-29 Texas Instruments Incorporated Computer memory system
US4754394A (en) * 1984-10-24 1988-06-28 International Business Machines Corporation Multiprocessing system having dynamically allocated local/global storage and including interleaving transformation circuit for transforming real addresses to corresponding absolute address of the storage
CA1234224A (en) * 1985-05-28 1988-03-15 Boleslav Sykora Computer memory management system

Non-Patent Citations (4)

* Cited by examiner, † Cited by third party
Title
COMMUNICATIONS OF THE ASSOCIATION FOR COMPUTING MACHINERY October 1961, NEW YORK US pages 421 - 422 R.J.MAHER 'Problems of Storage Allocation in a Multiprocessor Multiprogrammed System' *
IBM TECHNICAL DISCLOSURE BULLETIN vol. 28, no. 12, May 1986, NEW YORK US pages 5615 - 5620 'Overlay Linker and Loader Process' *
IBM TECHNICAL DISCLOSURE BULLETIN vol. 29, no. 6, November 1986, NEW YORK US pages 2794 - 2795 'Dynamically Freeing and Allocating a Reserved Memory Area Used to Load and Execute Mini Applications' *
IEEE TRANSACTIONS ON COMPUTERS vol. C-19, no. 6, June 1970, pages 492 - 503 D.P.BOVET ET AL. 'On Static Memory Allocation in Computer Systems' *

Cited By (10)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
EP0590645A1 (en) * 1992-09-30 1994-04-06 Microsoft Corporation Method and system for reducing memory allocation requests
US5675793A (en) * 1992-09-30 1997-10-07 Microsoft Corporation Dynamic allocation of a common buffer for use by a set of software routines
WO1995022104A1 (en) * 1994-02-14 1995-08-17 Ni-Tech Pty. Limited Use of multiple applications and allocation of memory or other resources in a gui environment
GB2301210A (en) * 1994-02-14 1996-11-27 Ni Tech Pty Limited Use of multiple applications and allocation of memory or other resources in a GUI environment
GB2301210B (en) * 1994-02-14 1998-11-18 Ni Tech Pty Limited Use of multiple applications and allocation of memory or other resources in a GUI environment
CN100539713C (en) 2004-08-31 2009-09-09 华为技术有限公司 Method for memorying data flow in single-board
US7401199B2 (en) * 2006-06-28 2008-07-15 Motorola, Inc Method and system for allocating memory to an electronic device
US20100070974A1 (en) * 2008-09-17 2010-03-18 Canon Kabushiki Kaisha Support apparatus for information processing apparatus, support method and computer program
US9135070B2 (en) * 2008-09-17 2015-09-15 Canon Kabushiki Kaisha Preventing memory exhaustion of information processing apparatus based on the predicted peak memory usage and total memory leakage amount using historical data
WO2018050528A1 (en) * 2016-09-16 2018-03-22 Siemens Rail Automation Holdings Limited Statically determining a program memory requirements

Also Published As

Publication number Publication date Type
US5247674A (en) 1993-09-21 grant
EP0456275A3 (en) 1993-07-21 application
JPH0418638A (en) 1992-01-22 application

Similar Documents

Publication Publication Date Title
US6698017B1 (en) Software migration on an active processing element
US5161226A (en) Microprocessor inverse processor state usage
US6308318B2 (en) Method and apparatus for handling asynchronous exceptions in a dynamic translation system
US6631515B1 (en) Method and apparatus to reduce code size and runtime in a Java environment
US7356817B1 (en) Real-time scheduling of virtual machines
US6308315B1 (en) System and method for automatically and selectively promoting object variables to method fields and variables in a digital computer system
US5659701A (en) Apparatus and method for distributed program stack
US5414848A (en) Method and apparatus for sharing a common routine stored in a single virtual machine with other virtual machines operating in a preemptive muli-tasking computer system
US6029004A (en) Method and apparatus for modular reordering of portions of a computer program based on profile data
US6832369B1 (en) Object oriented method and apparatus for class variable initialization
US6189141B1 (en) Control path evaluating trace designator with dynamically adjustable thresholds for activation of tracing for high (hot) activity and low (cold) activity of flow control
US5701476A (en) Method and apparatus for dynamically loading a driver routine in a computer memory
US5361362A (en) Adaptive job scheduling for multiprocessing systems with master and slave processors executing tasks with opposite anticipated execution times respectively
Chernoff et al. FX! 32: A profile-directed binary translator
US5774730A (en) Method and apparatus for improving colorability of constrained nodes in an interference graph within a computer system
US5995754A (en) Method and apparatus for dynamically optimizing byte-coded programs
US5247678A (en) Load time linker for software used with a multiprocessor system
US6148437A (en) System and method for jump-evaluated trace designation
US6256704B1 (en) Task management for data accesses to multiple logical partitions on physical disk drives in computer systems
US7275241B2 (en) Dynamic instrumentation for a mixed mode virtual machine
US20040030882A1 (en) Managed application pre-launching
US6059840A (en) Automatic scheduling of instructions to reduce code size
US6760907B2 (en) Code generation for a bytecode compiler
US4912628A (en) Suspending and resuming processing of tasks running in a virtual machine data processing system
US5960198A (en) Software profiler with runtime control to enable and disable instrumented executable

Legal Events

Date Code Title Description
AK Designated contracting states:

Kind code of ref document: A2

Designated state(s): DE FR GB

AK Designated contracting states:

Kind code of ref document: A3

Designated state(s): DE FR GB

17P Request for examination filed

Effective date: 19940108

17Q First examination report

Effective date: 19961209

18D Deemed to be withdrawn

Effective date: 19971125