System and method for checking the use of synchronization locks in a multi-threaded target program

A method for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said method comprising the steps of:

• providing a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• providing within said modified ANSI C compiler a modified analysis module configured to process annotations which are coded as extensions to C language code;
• providing within said modified ANSI C compiler a module configured to summarize said annotations which are coded as extensions to C language code;
• providing an analyzer program configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations;
• and
• under computer control using said modified ANSI C compiler to process annotated source code for said target program, and said analyzer program to check usage of synchronization locks as specified by said source code as compared to uses of said synchronization locks as specified by said annotations and display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer program.

A method for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said method comprising the steps of:

• providing a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• providing an analyzer program configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the step of providing an analyzer program comprises the additional step of providing within said analyzer program a set of data structures configured to contain representations of said annotated source code and wherein the set of data structures configured to contain representations of said annotated source code comprises a table of locks which contains for each lock at least a lock type, a current lock state, and a history of activity on said each lock;
• and
• under computer control using said modified ANSI C compiler to process annotated source code for said target program, and said analyzer program to check usage of synchronization locks as specified by said source code as compared to uses of said synchronization locks as specified by said annotations and display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer program.

A method for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said method comprising the steps of:

• providing a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• providing an analyzer program configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the step of providing an analyzer program comprises the additional step of providing within said analyzer program a set of data structures configured to contain representations of said annotated source code and wherein the set of data structures configured to contain representations of said annotated source code comprises a table of variables which contains for each variable at least a list of locks consistently held every time said each variable was accessed and an identification of a lock declared by annotation to protect said each variable, if said identification has been specified;
• and
• under computer control using said modified ANSI C compiler to process annotated source code for said target program, and said analyzer program to check usage of synchronization locks as specified by said source code as compared to uses of said synchronization locks as specified by said annotations and display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer program.

A method for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memos, an input and an output device and a display device, said method comprising the steps of:

• providing a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• providing an analyzer program configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the step of providing an analyzer program comprises the additional step of providing within said analyzer program a set of data structures configured to contain representations of said annotated source code and wherein the set of data structures configured to contain representations of said annotated source code comprises an adjacency matrix configured to record orderings between locks during a simulation of an execution of said target program and where a transitive closure can be performed on said orderings between locks to provide an indication of any deadlocks which may occur in said target program;
• and
• under computer control using said modified ANSI C compiler to process annotated source code for said target program, and said analyzer program to check usage of synchronization locks as specified by said source code as compared to uses of said synchronization locks as specified by said annotations and display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer program.

A modified ANSI C compiler for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device comprising:

• a modified analysis module configured to process annotated source code for said target program and to create annotations which are coded as extensions to C language code;
• a module configured to summarize said annotations which are coded as extensions to C language code, said summary for use in analyzing lock usage by said target program;
• and
• an output mechanism configured to produce an intermediate output file containing coded representations of the source code and coded representations of said annotations.

A computer program product comprising:

• a computer usable medium having computer readable program code mechanisms embodied therein configured to locate errors in the use of synchronization locks in a multi-threaded target program, the computer readable program code mechanisms in said computer program product comprising:
• computer readable code mechanisms configured to cause a computer to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotoations, wherein the annotations are in the form of a NOTE macro command;
• computer readable code mechanisms configured to cause the computer to process said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate output file and to compare said uses of synchronazation locks with lock uses specified in said annotaitons;
• and
• computer readable code mechanisms configured to cause the computer to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analysis.

A computer program product comprising:

• a computer usable medium having computer readable program code mechanisms embodied therein configured to locate errors in the use of synchronization locks in a multi-threaded target program, the computer readable program code mechanisms in said computer program product comprising:
• computer readable code mechanisms configured to cause a computer to process annotated source code for said target program and to create annotations which are coded as extensions to C language code;
• computer readable code mechanisms configured to cause the computer to summarize said annotations which are coded as extensions to C language code, said summary for use in analyzing lock usage by said target program;
• and
• computer readable code mechanisms configured to cause the computer to produce an intermediate output file containing coded representations of the source code and coded representations of said annotations.

An apparatus for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said apparatus comprising:

• a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations, wherein the annotations are in the form of a NOTE macro command;
• an analyzer device configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations;
• and
• a display mechanism coupled to said analyzer device and configured to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer device.

An apparatus for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said apparatus comprising:

• a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations wherein the modified ANSI C compiler comprises:
• a modified grammar module configured to process annotations which are coded as extensions to C language code;
• and
• a collection module configured to summarize said annotations which are coded as extensions to C language code, and
• an analyzer device configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations;
• and
• a display mechanism coupled to said analyzer device and configured to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer device.

An apparatus for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said apparatus comprising:

• a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• an analyzer device configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the analyzer device comprises a set of data structures configured to contain representations of said annotated source code wherein the set of data structures configured to contain representations of said annotated source code comprises a table of locks which contains for each lock at least a lock type, a current lock state, and a history of activity on said each lock;
• and
• a display mechanism coupled to said analyzer device and configured to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer device.

An apparatus for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said apparatus comprising:

• a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• an analyzer device configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the analyzer device comprises a set of data structures configured to contain representations of said annotated source code wherein the set of data structures configured to contain representations of said annotated source code comprises a table of variables which contains for each variable at least a list of locks consistently held every time said each variable was accessed and an identification of a lock declared by annotation to protect said each variable, if said identification has been specified;
• and
• a display mechanism coupled to said analyzer device and configured to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer device.

An apparatus for locating errors in the use of synchronization locks in a multi-threaded target program, through the use of a computer having a central processor unit, a memory, an input and an output device and a display device, said apparatus comprising:

• a modified ANSI C compiler which is configured to process annotated source code for said target program and to produce an intermediate output file containing coded representations of the source code and coded representations of annotations;
• an analyzer device configured to receive said intermediate output file and to analyze uses of synchronization locks by said source code in said intermediate file and to compare said uses of synchronization locks with lock uses specified in said annotations wherein the analyzer device comprises a set of data structures configured to contain representations of said annotated source code wherein the set of data structures configured to contain representations of said annotated source code comprises an adjacency matrix configured to record orderings between locks during a simulation of an execution of said target program and where a transitive closure can be performed on said orderings between locks to provide an indication of any deadlocks which may occur in said target program;
• and
• a display mechanism coupled to said analyzer device and configured to display at least a subset of inconsistencies in said usage of said synchronization locks as detected by said analyzer device.