CA2061298C - Method for detecting critical failures during the building of complex computer programs from source code parts - Google Patents
Method for detecting critical failures during the building of complex computer programs from source code partsInfo
- Publication number
- CA2061298C CA2061298C CA002061298A CA2061298A CA2061298C CA 2061298 C CA2061298 C CA 2061298C CA 002061298 A CA002061298 A CA 002061298A CA 2061298 A CA2061298 A CA 2061298A CA 2061298 C CA2061298 C CA 2061298C
- Authority
- CA
- Canada
- Prior art keywords
- source code
- code part
- listing
- compilation
- parts
- 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.)
- Expired - Fee Related
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
Abstract
A method for dynamically scheduling the building of computer programs from source code parts built and maintained separately in a source code parts library, and for efficiently identifying source code parts which cannot be compiled and integrated in the build for reasons such as circular compilation dependencies or references to non-existing, pre-requisite source code parts.
Description
20~1298 METHOD FOR DETECTING CRITICAL FAILURES DURING
BUILDING OF COMPLEX COMPUTER PROGRAMS FROM
SOURCE CODE PARTS
Description of field of invention The present invention relates generally to scheduling the building of computer programs from component parts and, in particular, for dynamically and efficiently scheduling the building of complex computer programs from source code parts accessed dynamically from a source code parts library.
Background of Invention In developing a complex computer program, it is efficient to create the program by integrating several smaller parts rather than writing a single large program.
The source code parts used in building the program can be created and maintained individually in a program library and accessed as desired. In building the complex program, each of its component source code parts is accessed and scheduled for compilation prior to integration into an executable program. For successful construction of the complex program, the several component source code parts required must be scheduled for compilation in the correct sequence. Logically independent source code parts must be scheduled for compilation before their dependent source code parts can be compiled.
Scheduling the compilation of source code parts without dependencies is relatively simple. However, the scheduling becomes complex when compilation dependencies and pre-requisites between source code parts arise as the compilation proceeds. This may happen because in the source code parts library, parts are maintained independently of each other on an on going basis. This may result in a modification to one source code part introducing dependencies on other source code parts which are unknown to the scheduler until the scheduler attempts to compile the part. In this event, if the scheduler cannot dynamically adapt to the new dependencies, the construction of the program will be stopped until the dependency problem is resolved.
Other problems may be encountered when scheduling the compilation of source code parts. The parts may have circular, pre-requisite compilation dependencies or have pre-requisites on non-existing source code parts. A
circular pre-requisite compilation dependency occurs where, for example, part A cannot be compiled until after the compilation of part B, and part B cannot be compiled until after the compilation of part A. When such circular compilation dependency occurs, an infinite scheduling loop will develop without the computer program being built.
Consequently, in order to efficiently construct a computer program from source code parts, the parts must be scheduled correctly, the compilation dependencies which arise between parts during compilation must be dynamically adapted by the scheduler into the schedule, and, when source code parts become involved in circular scheduling loops, the construction of the application must be stopped in a timely manner.
In the prior art, one way of integrating source code parts in building a computer program is to use a MAKE
facility. With a MAKE facility, make files are created by specifying in a file the source code parts that are needed in the build, and the order in which the source code parts should be made. With this approach to building a complex program the user must continually intervene in the process to keep the make files up-to-date and syntactically correct. This task is difficult when many source code parts are being modified, added to or deleted from a large source code parts library.
An alternative prior art approach is to use a source code parts scheduler which is capable of parsing the source code of each source code part prior to scheduling its compilation. This enables source code parts dependencies to be determined and thereby enable the scheduling of the compilation of the parts. A scheduler of this type requires a parser which is identical to the parser in each compiler that it supports. While this approach may be adequate where the scheduler supports source code parts coded in the same source language, it is inefficient where parts are written in several languages and are in the same parts library. Also, even if a parser was provided in a scheduler, by the time the actual compile is performed based on information learned from parsing the code, a compilation dependency may change due to source code parts maintenance, and therefore the information obtained for the schedule can become out of date.
Consequently the above two approaches are unsatisfactory. Additionally, neither approach is capable of dynamically adapting the schedule to dependencies between source code parts that become known as the parts are compiled.
US patent No. 4,852,001 assigned to Hitachi, Ltd.
discloses a job scheduling method for scheduling of jobs to various resources, wherein each workload of a job is allocated to each time unit along a time axis in units of job and resource type. The patent relates to timing of jobs and allocation of time and does not address the building of application programs and scheduling of dependencies.
US patent No. 4,791,554 assigned to Hitachi, Ltd.
discloses a computer system for parallel execution of several tasks by sharing several resources in a data base of a computer. The patent discusses "deadlock" due to the sharing of common resources and provides information to delay the start of a task that has the possibility of the deadlock. This patent also is not concerned with the problem addressed by the present invention.
US patent No. 4,658,351 assigned to Wang Laboratories, Inc. discloses a task control method and apparatus for controlling interactive, concurrent execution of several general purpose data processing tasks in a data processing system. The task manager includes several task queues with each queue corresponding to a relative priority level for execution of the task. Tasks are executed in a sequence depending upon the relative priorities of the task queues and upon the sequential location of task control blocks in a task queue. This patent also does not address the problem which this present invention solves.
The problem of scheduling the building of a computer program by scheduling the compilation of several interdependent source code parts from a library of parts, wherein a part may have several compilation dependencies unknown to the scheduler at the beginning of the build, has not been adequately addressed in the prior art. Also no known means presently is available for dynamically adapting to new compilation source code part dependencies which become known as the compilation proceeds. Also no known means is available for efficiently recognizing the existence of circular compilation dependencies among source code parts that may frustrate attempts to build the application.
S~mmary of Invention The present invention provides a method and means for dynamically scheduling the building of a computer program from several source code parts accessed from a computer parts library. Scheduling is done based on information returned to the scheduler from the compiler as each source code part is compiled.
A primary object of the present invention is to detect critical failures occuring during compilation of complex computer programs from multiple source code parts.
A further object of the present invention is to provide a process for compiling complex computer programs where compilation continues even where it has not been possible to compile a particular source code part.
The invention is more particularly defined as a method for locating critical failures during the building of complex computer programs which includes the steps of listing the source code parts re~uired for building the program, marking each part with a build status indicator, repetitively traversing the source code parts on the listing, attempting to compile each part as it is traversed according to the build status indicator and the 206~29~
parts dependencies and, where successful, replacing the build status indicator with a successful compilation indicator and stopping the traversing process only when no indicators are changed during a traversal of all the parts on the listing.
A further feature of the invention is the ability to add source code parts to the list while attempting to compile the parts.
In addition, listing of source code part dependencies are provided with each source part having a dependency on other parts so as to provide an indicator as to when a part is capable of being compiled.
The method of the present invention can be more particularly characterized in the following steps:
i) establishing an initial list of known source code parts required to build the application, i) marking each source code part on the list with a build status indicator, iii) scheduling the compiling of each source code part on the list one at a time, if they require compilation, iv) if the compilation of a source code part of step iii) is successful, changing the build status indicator of the source code part to indicate a successful compilation, v) if compilation of a source code part of step iii) is halted by a reference to a second source code part whose compilation is a pre-requisite to the compilation of the first source code part, and if the second source code part is not on the list, then adding the second source code part to the list and setting the build status indicator on the second source code part to indicate that the second source code part is to be compiled, and retaining unchanged the build status indicator on the first source code part and move to the next source code part on the list, vi) if the compilation of a source code part is halted by failure to compile for a reason other than the reason of step iv) above, setting the build status indicator on the source code part to indicate that the source code 20S12g~
part has failed to be compiled and move to the next source code part on the list, vii) repeating steps iii), iv) and v), iterating from start to end of the list until no change in the status indicators occurs during a full traverse of the list of source code parts, viii) on completion of vii) above, stopping the compilations and reporting the current status of the build status indicator for each source code part. At this point, source code parts which were successfully scheduled can be distinguished from those that were not.
The scheduler provided by the present invention will schedule the compilation of the source code parts as required including scheduling new parts as the build proceeds. If circular compiling dependencies between source code parts arise during the compilation causing an infinite scheduling loop, the method of the present invention will also efficiently stop the compilation.
Descriptions of Drawings FIG 1. illustrates the method of scheduling of LIST OF
PARTS and LIST OF DEPENDENCIES as provided by the present invention.
Fig 2. illustrates a generalized application of the present invention to schedule jobs that can be mapped to a directed graph.
Detailed Description of the Preferred Embodiment A preferred embodiment of the present invention, shown in FIG 1 has been implemented to build complex computer application programs from source code parts created and maintained in a computer program library. A
source code part is simply a computer program maintained in source code format which can be accessed and integrated into building a larger computer program.
Successful building of an application program from source code parts requires that the various parts be scheduled for compilation in correct order. For example, if source code part A depends upon source code part B for 20~2~8 compilation, the part B must be compiled prior to the compilation of part A.
At the start of the build process many of the compilation dependencies are known. However, because of ongoing file maintenance in the library, new compilation dependencies may be established which are unknown to the scheduler. These dependencies will appear as the source code parts are compiled.
For an efficient build, the scheduler must be able to adapt the schedule dynamically to any new dependencies that become known during compilation. Also, if as a result of the compilation, an infinite circular compilation dependency occurs between two or more parts, then the scheduler must be able to stop the build process.
In the preferred embodiment of the present invention, a pre-scheduler is used to create LISTS OF
PARTS by part type. The pre-scheduler puts similar types of files on the same LIST OF PARTS e.g. logical files and physical files, because of their potential for establishing circular compilation dependencies on each other or between themselves while other part types are placed on different lists.
As shown in FIG 1., source code parts for building an application program are represented as entries in a LIST OF PARTS 1. Similarly, the dependencies for a given source code part are shown as entries in a LIST OF
DEPENDENCIES 2. In the LIST OF PARTS 1 and the LIST OF
DEPENDENCIES 2, the order of the source code parts on each list does not matter. However, each source code part on the list has a scheduling status indicator 4 which indicates to the scheduler the compilation status of the part. The status indicator can be set at any one of the following:
1. TO_BE_BUILT: On encountering this status indicator, the scheduler determines whether or not the part can be scheduled for compilation. The scheduler will check all the known compilation dependent parts of the present part to determine whether or not the status indicator of all its compilation dependencies are set at BUILT. If they are all indicating BUILT, meaning that they have all been previously compiled, the scheduler will then schedule the compilation of the present part. If the status indicator on one or more compilation dependencies are set at TO_BE_BUILT and these parts are on the list, the scheduler will delay the scheduling of the present part and go to another part on the list. If all the dependent source code parts required are not on the list, the scheduler will then add new parts to the list as they become known.
BUILDING OF COMPLEX COMPUTER PROGRAMS FROM
SOURCE CODE PARTS
Description of field of invention The present invention relates generally to scheduling the building of computer programs from component parts and, in particular, for dynamically and efficiently scheduling the building of complex computer programs from source code parts accessed dynamically from a source code parts library.
Background of Invention In developing a complex computer program, it is efficient to create the program by integrating several smaller parts rather than writing a single large program.
The source code parts used in building the program can be created and maintained individually in a program library and accessed as desired. In building the complex program, each of its component source code parts is accessed and scheduled for compilation prior to integration into an executable program. For successful construction of the complex program, the several component source code parts required must be scheduled for compilation in the correct sequence. Logically independent source code parts must be scheduled for compilation before their dependent source code parts can be compiled.
Scheduling the compilation of source code parts without dependencies is relatively simple. However, the scheduling becomes complex when compilation dependencies and pre-requisites between source code parts arise as the compilation proceeds. This may happen because in the source code parts library, parts are maintained independently of each other on an on going basis. This may result in a modification to one source code part introducing dependencies on other source code parts which are unknown to the scheduler until the scheduler attempts to compile the part. In this event, if the scheduler cannot dynamically adapt to the new dependencies, the construction of the program will be stopped until the dependency problem is resolved.
Other problems may be encountered when scheduling the compilation of source code parts. The parts may have circular, pre-requisite compilation dependencies or have pre-requisites on non-existing source code parts. A
circular pre-requisite compilation dependency occurs where, for example, part A cannot be compiled until after the compilation of part B, and part B cannot be compiled until after the compilation of part A. When such circular compilation dependency occurs, an infinite scheduling loop will develop without the computer program being built.
Consequently, in order to efficiently construct a computer program from source code parts, the parts must be scheduled correctly, the compilation dependencies which arise between parts during compilation must be dynamically adapted by the scheduler into the schedule, and, when source code parts become involved in circular scheduling loops, the construction of the application must be stopped in a timely manner.
In the prior art, one way of integrating source code parts in building a computer program is to use a MAKE
facility. With a MAKE facility, make files are created by specifying in a file the source code parts that are needed in the build, and the order in which the source code parts should be made. With this approach to building a complex program the user must continually intervene in the process to keep the make files up-to-date and syntactically correct. This task is difficult when many source code parts are being modified, added to or deleted from a large source code parts library.
An alternative prior art approach is to use a source code parts scheduler which is capable of parsing the source code of each source code part prior to scheduling its compilation. This enables source code parts dependencies to be determined and thereby enable the scheduling of the compilation of the parts. A scheduler of this type requires a parser which is identical to the parser in each compiler that it supports. While this approach may be adequate where the scheduler supports source code parts coded in the same source language, it is inefficient where parts are written in several languages and are in the same parts library. Also, even if a parser was provided in a scheduler, by the time the actual compile is performed based on information learned from parsing the code, a compilation dependency may change due to source code parts maintenance, and therefore the information obtained for the schedule can become out of date.
Consequently the above two approaches are unsatisfactory. Additionally, neither approach is capable of dynamically adapting the schedule to dependencies between source code parts that become known as the parts are compiled.
US patent No. 4,852,001 assigned to Hitachi, Ltd.
discloses a job scheduling method for scheduling of jobs to various resources, wherein each workload of a job is allocated to each time unit along a time axis in units of job and resource type. The patent relates to timing of jobs and allocation of time and does not address the building of application programs and scheduling of dependencies.
US patent No. 4,791,554 assigned to Hitachi, Ltd.
discloses a computer system for parallel execution of several tasks by sharing several resources in a data base of a computer. The patent discusses "deadlock" due to the sharing of common resources and provides information to delay the start of a task that has the possibility of the deadlock. This patent also is not concerned with the problem addressed by the present invention.
US patent No. 4,658,351 assigned to Wang Laboratories, Inc. discloses a task control method and apparatus for controlling interactive, concurrent execution of several general purpose data processing tasks in a data processing system. The task manager includes several task queues with each queue corresponding to a relative priority level for execution of the task. Tasks are executed in a sequence depending upon the relative priorities of the task queues and upon the sequential location of task control blocks in a task queue. This patent also does not address the problem which this present invention solves.
The problem of scheduling the building of a computer program by scheduling the compilation of several interdependent source code parts from a library of parts, wherein a part may have several compilation dependencies unknown to the scheduler at the beginning of the build, has not been adequately addressed in the prior art. Also no known means presently is available for dynamically adapting to new compilation source code part dependencies which become known as the compilation proceeds. Also no known means is available for efficiently recognizing the existence of circular compilation dependencies among source code parts that may frustrate attempts to build the application.
S~mmary of Invention The present invention provides a method and means for dynamically scheduling the building of a computer program from several source code parts accessed from a computer parts library. Scheduling is done based on information returned to the scheduler from the compiler as each source code part is compiled.
A primary object of the present invention is to detect critical failures occuring during compilation of complex computer programs from multiple source code parts.
A further object of the present invention is to provide a process for compiling complex computer programs where compilation continues even where it has not been possible to compile a particular source code part.
The invention is more particularly defined as a method for locating critical failures during the building of complex computer programs which includes the steps of listing the source code parts re~uired for building the program, marking each part with a build status indicator, repetitively traversing the source code parts on the listing, attempting to compile each part as it is traversed according to the build status indicator and the 206~29~
parts dependencies and, where successful, replacing the build status indicator with a successful compilation indicator and stopping the traversing process only when no indicators are changed during a traversal of all the parts on the listing.
A further feature of the invention is the ability to add source code parts to the list while attempting to compile the parts.
In addition, listing of source code part dependencies are provided with each source part having a dependency on other parts so as to provide an indicator as to when a part is capable of being compiled.
The method of the present invention can be more particularly characterized in the following steps:
i) establishing an initial list of known source code parts required to build the application, i) marking each source code part on the list with a build status indicator, iii) scheduling the compiling of each source code part on the list one at a time, if they require compilation, iv) if the compilation of a source code part of step iii) is successful, changing the build status indicator of the source code part to indicate a successful compilation, v) if compilation of a source code part of step iii) is halted by a reference to a second source code part whose compilation is a pre-requisite to the compilation of the first source code part, and if the second source code part is not on the list, then adding the second source code part to the list and setting the build status indicator on the second source code part to indicate that the second source code part is to be compiled, and retaining unchanged the build status indicator on the first source code part and move to the next source code part on the list, vi) if the compilation of a source code part is halted by failure to compile for a reason other than the reason of step iv) above, setting the build status indicator on the source code part to indicate that the source code 20S12g~
part has failed to be compiled and move to the next source code part on the list, vii) repeating steps iii), iv) and v), iterating from start to end of the list until no change in the status indicators occurs during a full traverse of the list of source code parts, viii) on completion of vii) above, stopping the compilations and reporting the current status of the build status indicator for each source code part. At this point, source code parts which were successfully scheduled can be distinguished from those that were not.
The scheduler provided by the present invention will schedule the compilation of the source code parts as required including scheduling new parts as the build proceeds. If circular compiling dependencies between source code parts arise during the compilation causing an infinite scheduling loop, the method of the present invention will also efficiently stop the compilation.
Descriptions of Drawings FIG 1. illustrates the method of scheduling of LIST OF
PARTS and LIST OF DEPENDENCIES as provided by the present invention.
Fig 2. illustrates a generalized application of the present invention to schedule jobs that can be mapped to a directed graph.
Detailed Description of the Preferred Embodiment A preferred embodiment of the present invention, shown in FIG 1 has been implemented to build complex computer application programs from source code parts created and maintained in a computer program library. A
source code part is simply a computer program maintained in source code format which can be accessed and integrated into building a larger computer program.
Successful building of an application program from source code parts requires that the various parts be scheduled for compilation in correct order. For example, if source code part A depends upon source code part B for 20~2~8 compilation, the part B must be compiled prior to the compilation of part A.
At the start of the build process many of the compilation dependencies are known. However, because of ongoing file maintenance in the library, new compilation dependencies may be established which are unknown to the scheduler. These dependencies will appear as the source code parts are compiled.
For an efficient build, the scheduler must be able to adapt the schedule dynamically to any new dependencies that become known during compilation. Also, if as a result of the compilation, an infinite circular compilation dependency occurs between two or more parts, then the scheduler must be able to stop the build process.
In the preferred embodiment of the present invention, a pre-scheduler is used to create LISTS OF
PARTS by part type. The pre-scheduler puts similar types of files on the same LIST OF PARTS e.g. logical files and physical files, because of their potential for establishing circular compilation dependencies on each other or between themselves while other part types are placed on different lists.
As shown in FIG 1., source code parts for building an application program are represented as entries in a LIST OF PARTS 1. Similarly, the dependencies for a given source code part are shown as entries in a LIST OF
DEPENDENCIES 2. In the LIST OF PARTS 1 and the LIST OF
DEPENDENCIES 2, the order of the source code parts on each list does not matter. However, each source code part on the list has a scheduling status indicator 4 which indicates to the scheduler the compilation status of the part. The status indicator can be set at any one of the following:
1. TO_BE_BUILT: On encountering this status indicator, the scheduler determines whether or not the part can be scheduled for compilation. The scheduler will check all the known compilation dependent parts of the present part to determine whether or not the status indicator of all its compilation dependencies are set at BUILT. If they are all indicating BUILT, meaning that they have all been previously compiled, the scheduler will then schedule the compilation of the present part. If the status indicator on one or more compilation dependencies are set at TO_BE_BUILT and these parts are on the list, the scheduler will delay the scheduling of the present part and go to another part on the list. If all the dependent source code parts required are not on the list, the scheduler will then add new parts to the list as they become known.
2. BUILT: A part having this indicator has been scheduled and compiled. A part will also have this indicator if the part does not require compiling.
3. FAILED: On encountering this indicator, the scheduler will stop the scheduling and/or compiling of the part. This is because either the part itself or one or more of its dependencies had FAILED to compile due to syntax or other errors. When a part fails to compile, the scheduler marks the part as FAILED and any parts that were dependent on that part will not compile and will also be marked as FAILED by the scheduler.
In scheduling the parts for compilation, the scheduler will iteratively traverse the LIST OF PARTS 1 and LIST OF DEPENDENCIES 2, if any, one part at a time in a loop as illustrated at 3 in FIG 1. As it traverses the list, the scheduler checks each source code part status indicator. When the status indicator shows either BUILT
or FAILED, the scheduler will not do anything further with that part. When a TO_BE BUILT status indicator is encountered, the scheduler will check whether the part can be now be compiled and if it can, the part will be scheduled for compilation.
The scheduler will repetitively traverse the list until during an entire traversal of the list no more parts are processed. This would be indicated by no changes in any status indicator from TO BE_BUILT to BUILT
or FAILED during the traversal. Once this final traversal loop has been completed, the list of parts will contain source code parts that are compiled (BUILT), and source code parts that are not (FAILED or TO BE BUILT). The parts that are not completed (parts with TO_BE BUILT
indicator on) are source code parts that are either in a circular compilation dependency, dependent on parts within a circular dependency or refer to non-existing source code parts.
With reference to FIG 1, the above method can be summarized as follows:
1. At the start of the scheduling process, part A is examined. If the scheduling status flag is set at TO BE_BUILT, and part A has no dependencies, part A is compiled, and the scheduling status indicator is set to BUILT.
2. Next part B is examined. Assume that the scheduling status flag is set at TO_BE BUILT. Since part B is dependent on the prior compilation of part C which has not yet been processed, part B cannot be compiled on this traverse. Therefore its status indicator is not changed.
3) Part C is next examined. If the scheduling status flag is TO_BE_BUILT, and since there are no known dependencies, part C is compiled, and the status indicator on part C is set to BUILT.
In scheduling the parts for compilation, the scheduler will iteratively traverse the LIST OF PARTS 1 and LIST OF DEPENDENCIES 2, if any, one part at a time in a loop as illustrated at 3 in FIG 1. As it traverses the list, the scheduler checks each source code part status indicator. When the status indicator shows either BUILT
or FAILED, the scheduler will not do anything further with that part. When a TO_BE BUILT status indicator is encountered, the scheduler will check whether the part can be now be compiled and if it can, the part will be scheduled for compilation.
The scheduler will repetitively traverse the list until during an entire traversal of the list no more parts are processed. This would be indicated by no changes in any status indicator from TO BE_BUILT to BUILT
or FAILED during the traversal. Once this final traversal loop has been completed, the list of parts will contain source code parts that are compiled (BUILT), and source code parts that are not (FAILED or TO BE BUILT). The parts that are not completed (parts with TO_BE BUILT
indicator on) are source code parts that are either in a circular compilation dependency, dependent on parts within a circular dependency or refer to non-existing source code parts.
With reference to FIG 1, the above method can be summarized as follows:
1. At the start of the scheduling process, part A is examined. If the scheduling status flag is set at TO BE_BUILT, and part A has no dependencies, part A is compiled, and the scheduling status indicator is set to BUILT.
2. Next part B is examined. Assume that the scheduling status flag is set at TO_BE BUILT. Since part B is dependent on the prior compilation of part C which has not yet been processed, part B cannot be compiled on this traverse. Therefore its status indicator is not changed.
3) Part C is next examined. If the scheduling status flag is TO_BE_BUILT, and since there are no known dependencies, part C is compiled, and the status indicator on part C is set to BUILT.
4) As a result of this first traverse through the list, at least one part in the list had its scheduling status flag changed. The flags for parts A and C were changed from TO_BE_BUILT to BUILT. The scheduler will go back to the top of the list and repeat steps 1, 2, and 3 above.
5) Part A is now examined again. The scheduling status flag is now BUILT from the previous traverse so nothing is done on this traverse.
6) Part B is examined. On this occasion, the scheduling status flag is TO_BE_BUILT, but the dependencies A and C
are all now BUILT, so part B is now compiled, and the scheduling status indicator is set to BUILT.
are all now BUILT, so part B is now compiled, and the scheduling status indicator is set to BUILT.
7) Part C is examined. From the previous traverse the status indicator was set at BUILT, so nothing is done on C.
The traverse through the list begins again from part A through part C, but since no parts scheduling status flags are changed during this third traverse through the loop, the process is stopped. However, if a new CA9-91-001 10 2 0 ~12 9 8 dependency were found during the compilation, the part would be added to the end of the list after part C and thus become part of the scheduler traversal list. The cycle would repeat until there is no change in any status indicator flag.
The method of the present invention can be represented in pseudo code format as shown in Table 1.
Pseudo Code DO FOREVER
Set PART_STATUS_CHANGED flag to FALSE
Point to the first part in the LIST OF PARTS
DO WHILE the last part in the LIST OF PARTS is not visited IF the current PART is TO_BE_BUILT THEN
IF the part does not need to be compiled THEN
Set SCHEDULING_STATUS flag to BUILT
ELSE
Compile the part Add any new dependencies learned from the compiler to the parts dependency list, and to the LIST OF
PARTS (if necessary), with their SCHEDULING_STATUS
flag set to TO_BE_BUILT.
IF there are no dependencies that are TO_BE_BUILT
THEN
Set the current part's SCHEDULING_STATUS flag to BUILT.
END
END /* IF */
END /* IF */
IF the current part's SCHEDULING_STATUS flag has changed THEN
Set PART_STATUS_CHANGED flag to TRUE
END /* IF */
END /* DO WHILE */
AAAAAAAA*AAAAAAAAAAAA*AAAAAAAAAA******AAAAAAA****AAAAAAAA
¦* Determine if there is a cycle *l AAAAAAA*AAAA*AAAAAAAAAAAA****AAAA********AAAA*AAAAAA*****
IF the PART_STATUS_CHANGED flag is FALSE THEN
Point to the first part in the LIST OF PARTS
DO WHILE the last part in the LIST OF PARTS is not visited IF the current part's SCHEDULING_STATUS is TO_BE_BUILT THEN
Issue a warning stating this part is dependent on a part that can't be built.
END /* IF */
END /* DO WHILE */
Leave this method.
END /* IF */
END /* DO FOREVER */
Table 1~
In contrast to the before-the-fact scheduling approaches used in the prior art with either a make file facility or a program parser incorporated in the scheduler, the present invention is an after-the-fact scheduling approach based on information provided by the compiler as the parts are compiled. The result of the present invention is an efficient method for scheduling parts in building the computer application program and for identifying source code parts which cannot be compiled because of circular compilation dependency or because of the non-existence of a prerequisite source code part.
In implementing the present invention in a computer system to build an application program from several source code parts, computer memory is required only to maintain a lists of parts and lists of dependent parts.
No extra memory or computer processing capacity are required to identify parts in infinite circular dependencies, nor is any extra processing capacity needed to handle new, dependent parts which become known as the compilation proceeds.
The traverse through the list begins again from part A through part C, but since no parts scheduling status flags are changed during this third traverse through the loop, the process is stopped. However, if a new CA9-91-001 10 2 0 ~12 9 8 dependency were found during the compilation, the part would be added to the end of the list after part C and thus become part of the scheduler traversal list. The cycle would repeat until there is no change in any status indicator flag.
The method of the present invention can be represented in pseudo code format as shown in Table 1.
Pseudo Code DO FOREVER
Set PART_STATUS_CHANGED flag to FALSE
Point to the first part in the LIST OF PARTS
DO WHILE the last part in the LIST OF PARTS is not visited IF the current PART is TO_BE_BUILT THEN
IF the part does not need to be compiled THEN
Set SCHEDULING_STATUS flag to BUILT
ELSE
Compile the part Add any new dependencies learned from the compiler to the parts dependency list, and to the LIST OF
PARTS (if necessary), with their SCHEDULING_STATUS
flag set to TO_BE_BUILT.
IF there are no dependencies that are TO_BE_BUILT
THEN
Set the current part's SCHEDULING_STATUS flag to BUILT.
END
END /* IF */
END /* IF */
IF the current part's SCHEDULING_STATUS flag has changed THEN
Set PART_STATUS_CHANGED flag to TRUE
END /* IF */
END /* DO WHILE */
AAAAAAAA*AAAAAAAAAAAA*AAAAAAAAAA******AAAAAAA****AAAAAAAA
¦* Determine if there is a cycle *l AAAAAAA*AAAA*AAAAAAAAAAAA****AAAA********AAAA*AAAAAA*****
IF the PART_STATUS_CHANGED flag is FALSE THEN
Point to the first part in the LIST OF PARTS
DO WHILE the last part in the LIST OF PARTS is not visited IF the current part's SCHEDULING_STATUS is TO_BE_BUILT THEN
Issue a warning stating this part is dependent on a part that can't be built.
END /* IF */
END /* DO WHILE */
Leave this method.
END /* IF */
END /* DO FOREVER */
Table 1~
In contrast to the before-the-fact scheduling approaches used in the prior art with either a make file facility or a program parser incorporated in the scheduler, the present invention is an after-the-fact scheduling approach based on information provided by the compiler as the parts are compiled. The result of the present invention is an efficient method for scheduling parts in building the computer application program and for identifying source code parts which cannot be compiled because of circular compilation dependency or because of the non-existence of a prerequisite source code part.
In implementing the present invention in a computer system to build an application program from several source code parts, computer memory is required only to maintain a lists of parts and lists of dependent parts.
No extra memory or computer processing capacity are required to identify parts in infinite circular dependencies, nor is any extra processing capacity needed to handle new, dependent parts which become known as the compilation proceeds.
Claims (15)
1. In a computer, a method for building a software program from a list of source code parts comprising the steps of:
i) associating each source code part in said list with a build status indicator set to indicate that the source code parts are to be compiled;
ii) selecting and compiling a source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled;
iii) if the compilation of said selected source code part in step ii) is successful, changing the build status indicator for said selected source code part to indicate successful compilation;
iv) if the compilation of selected source code part of step ii) failed because of reference to a depended source code part whose compilation is a prerequisite to the compilation of said selected source code part and if said depended source code part is not on said list, then adding said depended source code part to said list and setting the build status indicator for said depended source code part to indicate that said depended source code part is to be compiled;
v) if the compilation of said selected source code part is halted by failure to compile for a reason other than the reason of step iv) above, setting the build status indicator for said selected source code part to indicate failure to compile;
(vi) repeating steps ii), iii), iv) and v) for each source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled until a specific state of the build status indicators occurs during a full traverse of said first of source code parts; and vii) storing the build status indicators for each source code part in said list as an indication of the build status for the software program.
i) associating each source code part in said list with a build status indicator set to indicate that the source code parts are to be compiled;
ii) selecting and compiling a source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled;
iii) if the compilation of said selected source code part in step ii) is successful, changing the build status indicator for said selected source code part to indicate successful compilation;
iv) if the compilation of selected source code part of step ii) failed because of reference to a depended source code part whose compilation is a prerequisite to the compilation of said selected source code part and if said depended source code part is not on said list, then adding said depended source code part to said list and setting the build status indicator for said depended source code part to indicate that said depended source code part is to be compiled;
v) if the compilation of said selected source code part is halted by failure to compile for a reason other than the reason of step iv) above, setting the build status indicator for said selected source code part to indicate failure to compile;
(vi) repeating steps ii), iii), iv) and v) for each source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled until a specific state of the build status indicators occurs during a full traverse of said first of source code parts; and vii) storing the build status indicators for each source code part in said list as an indication of the build status for the software program.
2. A system for building a software program from a list of source code parts comprising the steps of:
i) means for associating each source code part in said list with a build status indicator set to indicate that the source code parts are to be compiled;
ii) means for selecting and compiling a source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled;
iii) means, responsive to the means for compiling, for changing the build status indicator for said selected source code part to indicate successful compilation, if the compilation of said selected source code part in step ii) is successful;
iv) means, responsive to the means for compiling, for adding a depended source code part to said list and setting the build status indicator for said depended source code part to indicate that said depended source code part is to be complied, if the compilation of selected source code part failed because of a prerequisite reference to said depended source code part whose compilation is a prerequisite to the compilation of said selected source code part and if said depended source code part is not on said list;
v) means, responsive to the means for compiling, for setting the build status indicator for said selected source code part to indicate failure to compile, if the compilation of said selected source code part failed to compile for a reason other than a prerequisite reference;
vi) means for repeatedly activating means ii), iii), iv) and v) for each source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled, until a specific state of the build status indicators occurs during a full traverse of said list of source code parts; and vii) means for storing the build status indicators for each source code part in said list as an indication of the build status for the software program.
i) means for associating each source code part in said list with a build status indicator set to indicate that the source code parts are to be compiled;
ii) means for selecting and compiling a source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled;
iii) means, responsive to the means for compiling, for changing the build status indicator for said selected source code part to indicate successful compilation, if the compilation of said selected source code part in step ii) is successful;
iv) means, responsive to the means for compiling, for adding a depended source code part to said list and setting the build status indicator for said depended source code part to indicate that said depended source code part is to be complied, if the compilation of selected source code part failed because of a prerequisite reference to said depended source code part whose compilation is a prerequisite to the compilation of said selected source code part and if said depended source code part is not on said list;
v) means, responsive to the means for compiling, for setting the build status indicator for said selected source code part to indicate failure to compile, if the compilation of said selected source code part failed to compile for a reason other than a prerequisite reference;
vi) means for repeatedly activating means ii), iii), iv) and v) for each source code part in said list whose status indicator is set to indicate that said selected source code part is to be compiled, until a specific state of the build status indicators occurs during a full traverse of said list of source code parts; and vii) means for storing the build status indicators for each source code part in said list as an indication of the build status for the software program.
3. A method as in claim 1, wherein the specific state of the build status indicators recited in step vi) is that there that there is no change in any build status indicator.
4. A system as in claim 2, wherein the specific state of the build status indicators recited in step vi) is that there is no change in any build status indicator.
5. In a computer, a method for building complex computer programs from source code parts, said source code parts comprising objects obtained from a program library, said method comprising the steps of:
i) listing in a first listing source code parts required for building a complex computer program;
ii) marking each source code part in said first listing with a build status indicator indicative of a status of compilation:
iii) repetitively traversing said first listing, iv) attempting to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator; and v) stopping said traversing of said first listing when a traverse of said first listing creates a specific state of the build status indicators.
i) listing in a first listing source code parts required for building a complex computer program;
ii) marking each source code part in said first listing with a build status indicator indicative of a status of compilation:
iii) repetitively traversing said first listing, iv) attempting to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator; and v) stopping said traversing of said first listing when a traverse of said first listing creates a specific state of the build status indicators.
6. A method as defined in claim 5, further comprising the step of adding source code parts from said program library to said first listing when an attempt to compile a source code part identifies a dependency on a source code part not included in said first listing but available in said program library.
7. A method as defined in claim 5 further including, for each source code part in said first listing, a second listing of any source code parts upon which each source code part in said first listing depends, said second listings having all indicator for indicating the build status of each source code part in said second listing.
8. A method as defined in claim 6 further including, for each source code part in said first listing, a second listing of any source code parts upon which each source code part in said first listing depends, said second listings having an indicator for indicating the build status of each source code part in said second listing.
9. A method as in claim 5 wherein said specific state of the build status indicators recited in step v) is that there is no change in any build status indicator based on a previous traversal of said first listing.
10. A system for building complex computer programs from source code parts, said source code parts comprising objects obtained from a program library, said system comprising:
a processor;
a controller to control said processor, comprising:
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator, and means for enabling said processor to stop said traversing of said first listing when a traverse of said first listing creates a specific state of said build status indicators.
a processor;
a controller to control said processor, comprising:
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator, and means for enabling said processor to stop said traversing of said first listing when a traverse of said first listing creates a specific state of said build status indicators.
11. The system of claim 10, wherein said controller further comprises means for enabling said processor to add source code parts from said program library to said first listing when art attempt to compile a source code part identifies a dependency on a source code part not included in said first listing but available in said program library.
12. A controller for enabling a processor to build complex computer programs from source code parts, said source code parts comprising objects obtained from a program library, said controller comprising:
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator; and means for enabling said processor to stop said traversing of said first listing when a traverse of said first listing creates a specific state of said build status indicators.
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator for said source code part with a successful compilation indicator; and means for enabling said processor to stop said traversing of said first listing when a traverse of said first listing creates a specific state of said build status indicators.
13. The controller of claims 12, further comprising means for enabling said processor to add source code parts from said program library to said first listing when an attempt to compile a source code part identifies a dependency on a source code part not included in said first listing but available in said program library.
14. A computer program product comprising a computer readable medium having computer program logic recorded thereon for enabling a processor in a computer system to build complex computer programs from source code parts, said source code parts comprising objects obtained from a program library, said computer program product comprising:
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator as said source code part with a successful compilation indicator, and means for enabling said processor to stop said traversing of said first listing when a traverse of said creates a specific state of said build status indicators.
means for enabling said processor to list in a first listing source code parts required for building a complex computer program, means for enabling said processor to mark each source code part in said first listing with a build status indicator indicative of a status of compilation, means for enabling said processor to repetitively traverse said first listing, means for enabling said processor to attempt to compile each said source code part according to said build status indicator as said first listing is traversed, and if said attempted compilation of said source code part is successful, replacing said build status indicator as said source code part with a successful compilation indicator, and means for enabling said processor to stop said traversing of said first listing when a traverse of said creates a specific state of said build status indicators.
15. The computer program product of claim 14, further comprising means for enabling said processor to add source code parts from said program library to said first listing when an attempt to compile a source code part identifies a dependency on a source code part not included in said first listing but available in said program library.
Priority Applications (5)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002061298A CA2061298C (en) | 1992-02-17 | 1992-02-17 | Method for detecting critical failures during the building of complex computer programs from source code parts |
| JP5021118A JP2802005B2 (en) | 1992-02-17 | 1993-02-09 | Failure detection method |
| US08/016,622 US5375239A (en) | 1992-02-17 | 1993-02-12 | Use of build status indicators in connection with building of complex computer programs from source code parts |
| US08/257,621 US5513357A (en) | 1992-02-17 | 1994-06-08 | Use of build status indicators in connection with building of complex computer programs from source code parts |
| US08/466,694 US5604908A (en) | 1992-02-17 | 1995-06-06 | Computer program product for using build status indicators in connection with building of complex computer programs from source code parts |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CA002061298A CA2061298C (en) | 1992-02-17 | 1992-02-17 | Method for detecting critical failures during the building of complex computer programs from source code parts |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CA2061298A1 CA2061298A1 (en) | 1993-08-18 |
| CA2061298C true CA2061298C (en) | 1996-12-03 |
Family
ID=4149269
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CA002061298A Expired - Fee Related CA2061298C (en) | 1992-02-17 | 1992-02-17 | Method for detecting critical failures during the building of complex computer programs from source code parts |
Country Status (3)
| Country | Link |
|---|---|
| US (3) | US5375239A (en) |
| JP (1) | JP2802005B2 (en) |
| CA (1) | CA2061298C (en) |
Families Citing this family (39)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CA2061298C (en) * | 1992-02-17 | 1996-12-03 | Douglas J. Mortson | Method for detecting critical failures during the building of complex computer programs from source code parts |
| US5848274A (en) * | 1996-02-29 | 1998-12-08 | Supercede, Inc. | Incremental byte code compilation system |
| US5764989A (en) * | 1996-02-29 | 1998-06-09 | Supercede, Inc. | Interactive software development system |
| CA2178898C (en) * | 1996-06-12 | 2000-02-01 | David Joseph Streeter | Sequencing and error detection of template instantiations during compilation of c++ programs |
| US6067413A (en) * | 1996-06-13 | 2000-05-23 | Instantations, Inc. | Data representation for mixed-language program development |
| US5787439A (en) * | 1996-12-13 | 1998-07-28 | Novell, Inc. | Method and system for maintaining a preferred sequence for accessing a plurality of objects |
| US5973687A (en) * | 1996-12-18 | 1999-10-26 | Sun Microsystems, Inc. | Graphical distributed make tool methods apparatus and computer program products |
| JP4027482B2 (en) * | 1997-12-24 | 2007-12-26 | 富士通株式会社 | Translation apparatus and method for performing cryptographic restoration |
| US6757900B1 (en) | 2000-05-18 | 2004-06-29 | Microsoft Corporation | State management of server-side control objects |
| US7013340B1 (en) | 2000-05-18 | 2006-03-14 | Microsoft Corporation | Postback input handling by server-side control objects |
| US7380250B2 (en) | 2001-03-16 | 2008-05-27 | Microsoft Corporation | Method and system for interacting with devices having different capabilities |
| US7493397B1 (en) | 2001-06-06 | 2009-02-17 | Microsoft Corporation | Providing remote processing services over a distributed communications network |
| US6944797B1 (en) | 2001-06-07 | 2005-09-13 | Microsoft Corporation | Method and system for tracing |
| US6915454B1 (en) | 2001-06-12 | 2005-07-05 | Microsoft Corporation | Web controls validation |
| US7162723B2 (en) * | 2001-06-29 | 2007-01-09 | Microsoft Corporation | ASP.NET HTTP runtime |
| US7594001B1 (en) | 2001-07-06 | 2009-09-22 | Microsoft Corporation | Partial page output caching |
| US7216294B2 (en) | 2001-09-04 | 2007-05-08 | Microsoft Corporation | Method and system for predicting optimal HTML structure without look-ahead |
| US7428725B2 (en) * | 2001-11-20 | 2008-09-23 | Microsoft Corporation | Inserting devices specific content |
| US20030233477A1 (en) * | 2002-06-17 | 2003-12-18 | Microsoft Corporation | Extensible infrastructure for manipulating messages communicated over a distributed network |
| US7574653B2 (en) * | 2002-10-11 | 2009-08-11 | Microsoft Corporation | Adaptive image formatting control |
| US7603664B2 (en) * | 2002-10-22 | 2009-10-13 | Sun Microsystems, Inc. | System and method for marking software code |
| JP3925857B2 (en) * | 2002-11-07 | 2007-06-06 | インターナショナル・ビジネス・マシーンズ・コーポレーション | Schedule creation method, program, and task schedule creation device |
| US7111287B2 (en) * | 2003-01-10 | 2006-09-19 | International Business Machines Corporation | Global processor resource assignment in an assembler |
| US7827216B1 (en) | 2003-07-23 | 2010-11-02 | Novell, Inc. | Method for coordinating relationships between multiple physical entities |
| US7596782B2 (en) | 2003-10-24 | 2009-09-29 | Microsoft Corporation | Software build extensibility |
| US7890604B2 (en) * | 2004-05-07 | 2011-02-15 | Microsoft Corproation | Client-side callbacks to server events |
| US20050251380A1 (en) * | 2004-05-10 | 2005-11-10 | Simon Calvert | Designer regions and Interactive control designers |
| US9026578B2 (en) * | 2004-05-14 | 2015-05-05 | Microsoft Corporation | Systems and methods for persisting data between web pages |
| US8065600B2 (en) | 2004-05-14 | 2011-11-22 | Microsoft Corporation | Systems and methods for defining web content navigation |
| US7464386B2 (en) * | 2004-05-17 | 2008-12-09 | Microsoft Corporation | Data controls architecture |
| US8156448B2 (en) * | 2004-05-28 | 2012-04-10 | Microsoft Corporation | Site navigation and site navigation data source |
| US7530058B2 (en) * | 2004-05-28 | 2009-05-05 | Microsoft Corporation | Non-compile pages |
| US20060020883A1 (en) * | 2004-05-28 | 2006-01-26 | Microsoft Corporation | Web page personalization |
| US20070185929A1 (en) * | 2006-02-01 | 2007-08-09 | Sap Portals Isreal Ltd. | Method and apparatus for processing monitoring |
| US8151253B2 (en) * | 2006-03-27 | 2012-04-03 | Oracle International Corporation | Efficient generation of executable file from program files when some of the program files expressly incorporate other program files |
| US20080196024A1 (en) * | 2007-02-08 | 2008-08-14 | Ibm Corporation | Method and Apparatus for Changing Software Components in an Information Handling System |
| US8108360B2 (en) * | 2008-04-17 | 2012-01-31 | Microsoft Corporation | Database object update order determination |
| US20150046903A1 (en) * | 2013-08-06 | 2015-02-12 | International Business Machines Incorporated | Predicting immediate build targets |
| WO2022120159A1 (en) * | 2020-12-03 | 2022-06-09 | Synopsys, Inc. | Automatic sequential retry on hardware design compilation failure |
Family Cites Families (13)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US4330822A (en) * | 1971-09-02 | 1982-05-18 | Burroughs Corporation | Recursive system and method for binding compiled routines |
| US4658351A (en) * | 1984-10-09 | 1987-04-14 | Wang Laboratories, Inc. | Task control means for a multi-tasking data processing system |
| JPS6194149A (en) * | 1984-10-15 | 1986-05-13 | Fujitsu Ltd | Translating sequence deciding system |
| JPS61233849A (en) * | 1985-04-08 | 1986-10-18 | Hitachi Ltd | Method for controlling exclusively data base |
| JP2533495B2 (en) * | 1986-07-25 | 1996-09-11 | 株式会社日立製作所 | Work scheduling method and apparatus |
| US4951192A (en) * | 1987-06-04 | 1990-08-21 | Apollo Computer, Inc. | Device for managing software configurations in parallel in a network |
| US5182807A (en) * | 1987-12-18 | 1993-01-26 | Nec Corporation | Assembler system for determining when to compile source code modules |
| JPH01240934A (en) * | 1988-03-23 | 1989-09-26 | Hitachi Ltd | Automatic re-compiling method |
| US5051893A (en) * | 1988-07-11 | 1991-09-24 | Digital Equipment Corporation | System for processing data to facilitate the creation of executable images |
| JPH0240720A (en) * | 1988-07-29 | 1990-02-09 | Nec Corp | Object program output instruction system |
| US4949255A (en) * | 1988-09-07 | 1990-08-14 | International Business Machines Corp. | Message interface and method for recursive calling between interpretive and compiled computer processes |
| US5175856A (en) * | 1990-06-11 | 1992-12-29 | Supercomputer Systems Limited Partnership | Computer with integrated hierarchical representation (ihr) of program wherein ihr file is available for debugging and optimizing during target execution |
| CA2061298C (en) * | 1992-02-17 | 1996-12-03 | Douglas J. Mortson | Method for detecting critical failures during the building of complex computer programs from source code parts |
-
1992
- 1992-02-17 CA CA002061298A patent/CA2061298C/en not_active Expired - Fee Related
-
1993
- 1993-02-09 JP JP5021118A patent/JP2802005B2/en not_active Expired - Lifetime
- 1993-02-12 US US08/016,622 patent/US5375239A/en not_active Expired - Fee Related
-
1994
- 1994-06-08 US US08/257,621 patent/US5513357A/en not_active Expired - Fee Related
-
1995
- 1995-06-06 US US08/466,694 patent/US5604908A/en not_active Expired - Fee Related
Also Published As
| Publication number | Publication date |
|---|---|
| US5604908A (en) | 1997-02-18 |
| US5513357A (en) | 1996-04-30 |
| JP2802005B2 (en) | 1998-09-21 |
| CA2061298A1 (en) | 1993-08-18 |
| US5375239A (en) | 1994-12-20 |
| JPH0683634A (en) | 1994-03-25 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CA2061298C (en) | Method for detecting critical failures during the building of complex computer programs from source code parts | |
| US6101524A (en) | Deterministic replay of multithreaded applications | |
| US5953530A (en) | Method and apparatus for run-time memory access checking and memory leak detection of a multi-threaded program | |
| US7185320B2 (en) | System and method for processing breakpoint events in a child process generated by a parent process | |
| Needham et al. | The Cambridge CAP computer and its protection system | |
| JP4965081B2 (en) | Method and system for detecting potential conflicts in a multithreaded program | |
| CN101681272B (en) | Parallelizing sequential frameworks using transactions | |
| US6351843B1 (en) | Dynamically inserting a function into an application executable at runtime | |
| EP0470322B1 (en) | Message-based debugging method | |
| US7971205B2 (en) | Handling of user mode thread using no context switch attribute to designate near interrupt disabled priority status | |
| WO1992015946A1 (en) | System and method for preserving source instruction atomicity in translated program code | |
| US6134627A (en) | Thread synchronization in a computer controlled by an object-based program | |
| US5862340A (en) | Method operating in each node of a computer system providing and utilizing special records for collective communication commands to increase work efficiency at each node | |
| Carver et al. | Deterministic execution testing of concurrent Ada programs | |
| CN111563000B (en) | File generation method, intelligent terminal and storage medium | |
| US9223637B1 (en) | Method and apparatus to advise spin and yield decisions | |
| US6311227B1 (en) | Procedure calling method | |
| Gliwa et al. | Operating Systems | |
| Locke et al. | Java technology comes to real-time applications | |
| Hölscher et al. | Examining and Supporting Multi-Tasking in EV3OSEK | |
| Antonelli | Exception handling in a multicontext environment | |
| Knoblauch | Deadlock Detection in OpenPEARL | |
| KR100293932B1 (en) | A technology for post image processig of compiled s/w code | |
| Starr et al. | Model Execution Domain | |
| Hansen | Concurrent Processes |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| EEER | Examination request | ||
| MKLA | Lapsed |