JP2013518352A - Method and apparatus for enhancing understanding of time complexity and flow in code - Google Patents

Abstract

  A method and apparatus that utilizes techniques for formatting assembly code and / or machine code using arrows, indentation, text symbols, etc., to improve programmers' understanding of program flow. There are advantages and disadvantages to different methods for estimating the calculation of time complexity (for example, the up-branch method and the strongly connected subgraph method), but there are advantages to using them together.

Description

(Cross-reference of related applications)
This application claims priority from US application 61 / 299,477, filed January 29, 2010, the entire contents of which are hereby incorporated by reference.

  The techniques herein automatically analyze the rough time complexity in the code and format the computer assembly and / or machine code to improve the understanding of the basic flow by the user reading the code. It relates to a method and an apparatus. More particularly, the techniques herein can be used to format and present assembly code and / or machine code graphically using arrows, indentation, text symbols, etc. The present invention relates to a technique using visual means for improving understanding of the flow and how the program operates.

(Background and overview)
When digital computers were first invented, programmers wrote programs in binary numbers (1 and 0) or hexadecimal numbers (0-F) that could be directly executed by the CPU of the computer. Since the 1960s, the front panel of many computers has been lined with switches that programmers can use to program binary instructions directly into the computer. However, writing code in binary numbers was a daunting task and error prone. As a result, programmers began to write in so-called "assembly language" from the 1950s. In assembly language, binary machine code instructions and human-written assembly language instructions have a one-to-one correspondence, but mnemonics (short memorized symbols) are used instead of machine language operation codes (opcodes). The symbol was used instead of the machine address. Even when writing in assembly language, programmers still needed a deep understanding of the hardware for which they were writing programs, but the programmer's work has been simplified and error free.

  Because assembly code is intimately intertwined with hardware functionality, a good assembly language programmer could optimize execution efficiency, reliability, speed, and program size. This was especially important when programmers wanted to get the full performance of resource-constrained computing platforms.

  Over half a century later, modern computers have a relatively large amount of resources in terms of processor speed, memory storage capacity, and other performance characteristics. There are also a vast number of computing platforms that currently have a variety of different types of processors and instruction sets. As a result, most modern computer programs are written primarily in high-level languages such as Java and C ++. Such high-level languages have many advantages, such as portability across multiple computing platforms and the absence of detailed human programmer manipulation of specific computing devices. A typical computing platform directly executes a high level language. Conversely, high-level instructions are first compiled or interpreted to create low-level “machine code” that can be executed by a particular processor executing those instructions. The entire industry specializes in developing compilers, linkers, and other tools that perform optimal conversions from high-level languages to machine code on various platforms.

  Generally speaking, if programmers are still writing all the code in assembler, it is impractical or impossible to provide the rich cross-platform software functionality that we take for granted today. Let's go. In fact, modern programmers who can master assembly are relatively rare. However, there are cases where their presence is still important by assembly language instructions and machine code instructions.

  For example, there are situations where extreme optimization is required when programming a game. As an example, it may be necessary to optimize the inner loop in a processor intensive algorithm in a game program that can be repeated hundreds or thousands of times per second. While there is an opinion that modern optimizing compilers can be optimized better than any human programmer, there is an objection to this that there is a good understanding of the target hardware and the number of instructions required to perform a certain function. Some think that there is no substitute for humans who can focus their creativity on minimization.

  Also, old game code originally written in assembly may now have to be understood and / or changed. Another interesting situation occurs when the programmer does not have access to the source code of a particular game, but must understand how a particular piece of game code executes. Although it is possible to disassemble machine code to obtain assembly language using mnemonics, understanding such code can be difficult, especially for programmers accustomed to writing in high-level languages.

  Programmers usually do not deal directly with machine code. However, it is sometimes necessary to code these instructions manually or to check the machine code generated by the compiler.

  Therefore, in such a case, it would be beneficial if the machine code could be visualized so that humans can more easily understand it. The techniques described herein are directed to a specific approach that enables humans to more easily understand the flow of control in a function or program by working together to improve and transform machine code.

  Regardless of what code you read, the flow of the program is very important for an overall understanding. Normally, the flow proceeds from one machine instruction to the next. However, conditional branches and unconditional branches cause execution to be skipped to any instruction with or without condition, and the flow becomes complicated. A flow can also be in a state known as a “loop” where a sequence of instructions can be executed any number of times by branching to previously executed instructions.

  In mathematics, computer science, and related fields, big O notation (also known as big-o notation, Landau notation, Bachman Landau notation, asymptotic notation), asymptotics of a function when an argument goes to a specific value or infinity Describe the behavior, usually replacing it with a simpler function. With the big O notation, the user can simplify the function and handle only these increasing rates, and even if different functions have the same increasing rate, they can be expressed in the same O notation. This notation has evolved as part of pure mathematics, but now it is often used for algorithm analysis to describe the usage of computational resources by the algorithm, and the worst or average execution time of the algorithm, Alternatively, memory usage is often expressed using big O notation as a function of its input length. This allows the algorithm designer to predict the behavior of the algorithm in a manner unrelated to the computer architecture and clock speed, and to determine which of the many algorithms to use. The Big O notation does not necessarily indicate the fastest practical algorithm or the fastest algorithm for a practically sized data set because it ignores the efficiency of truncating the multiplicative constant in execution time and reducing the input size. Nevertheless, this approach is still very effective in comparing the scalability of various algorithms as the input size increases. When a function is described by replacing it with the big O notation, the upper limit in the increase rate of the function is usually obtained. To describe other types of boundedness in asymptotic growth rates, several related notations are associated with the big O notation using symbols such as o, Ω, ω, Θ, and the like. The Big O notation is also used for the purpose of the same estimation in many other fields. See Wikipedia “Big O Notation”.

  There are other methods for analyzing program flow and computational complexity. An example of a non-limiting approach for purposes of illustration is based on an “indentation level” that represents a branching state. Generally speaking, a branch state or a loop state in a computer program is often indicated by indenting a code portion in the branch or loop. Thus, the four levels of loop status can be indicated by four level indentation. An example of a non-limiting implementation for purposes of illustration uses such a character array appearance to analyze the computational complexity of the program based on the indentation level. Changing from one indentation level to another can show changes in computational complexity. Generally speaking, the greater the indentation level, the more complex the program structure. Thus, automatic program analysis based on the indentation level can be a useful measure of the computational complexity of the program.

  An example of a non-limiting implementation for illustrative purposes is to automatically generate a forward / downward or backward / upward branch arrow that can be used to visually represent the flow of the program executed by the machine code. Show. By presenting in this way, the branch destination of each machine code instruction is emphasized, so that a person who reads it, such as a programmer, can grasp the program flow more easily and quickly.

  Another example of a non-limiting implementation for illustrative purposes is to automatically generate various machine code instruction line indentations that can be used to branch machine code from one machine code instruction to another. And visually show how it is divided naturally into blocks. In some implementations, the branch destination of the branch command is visually annotated in the machine code branch instruction, and indentation continues until a machine code instruction with a visual mark is encountered.

  In yet another example of a non-limiting implementation for purposes of illustration, machine code flow and complexity calculates the time complexity associated with each block of machine code or each machine code instruction, and the machine code accordingly Are automatically analyzed and visually annotated by marking their various components.

  Another method for analyzing the computational complexity of a program can be referred to as a “strongly connected subgraph method”, which can be used to detect a rough temporal computational complexity in the worst case of a program assembly instruction. In one example of a non-limiting implementation for purposes of illustration, the time complexity may be different from the program's structural complexity. Such a technique can be based on the code flow and the branch destination of the branch instruction, and may be detected by replacing the time calculation amount with a nested level. In such a technique, for example, a code flow graph is created, multiple strongly connected subgraphs are identified, multiple sets of multiple strongly connected subgraphs are created, a set graph is created, and the longest in the set graph is created. Analyzes routes, sorts multiple sets, and allocates time complexity for interpretation, display, etc.

  The strongly connected subgraph method comprehensively examines the contents of a sequence of instructions in units of lines, and identifies various transitions of cycles (representing each strongly connected subgraph), thereby enabling the contents of the dynamic flow of a program to be determined. Investigate. By detecting the nesting level in this way, the actual usage status of the program can be detected from its various parts.

  The indentation level or “up-branch method” for calculating the time complexity and the strongly connected subgraph method for calculating the time complexity have differences and respective advantages and disadvantages. For example, in the up-branch method, due to the nature of the algorithm grouping based on the line number, if the line of code may not actually be part of the cycle, the time complexity of this line will be increased by mistake. May be judged. The upbranch method is conservative and does not recognize that the first or last line of code is shared between multiple cycles, but does not recognize that it contains a cycle, and some cycles are partially compared to other cycles with respect to row numbers. It is not recognized that a cycle is included even if it overlaps with. On the other hand, the strongly connected subgraph method tends to positively recognize that the source code or the assembly code includes a cycle even if the result may not actually result in this amount of time calculation. This is because, for example, the actual calculation of each line of code that branches is not analyzed. In the strongly connected subgraph method, the time complexity of a line of code is never mistakenly determined to be less than the theoretically possible time complexity, so all the time complexity computed is the maximum. .

  Based on the advantages and disadvantages of the time complexity algorithm based on the up-branch method and the time complexity algorithm based on the strongly connected subgraph method, it is possible to adopt a method combining these. For example, a strongly connected subgraph method may be used to determine the worst time complexity that is theoretically possible (eg, based on naive code flow and branch flow). And the minimum time complexity of each line of code is selected from either the upbranch or strongly connected subgraph method, and the time complexity is conservatively estimated, while the error is larger than the actual that exists in the upbranch method. Can eliminate the time complexity.

  These and other features and advantages will be better and more fully understood by reference to the following detailed description of the non-limiting examples, given by way of illustration, in conjunction with the following drawings. Let's go.

FIG. 1 schematically illustrates the internal configuration of an example of a non-limiting computer system.

FIG. 2 schematically shows a non-limiting embodiment of a computer system according to the invention.

FIG. 3 shows an example of a non-limiting software flowchart for illustrative purposes.

FIG. 4 schematically illustrates a non-limiting example of a representation of a block of machine code having a branching arrow.

FIG. 5 schematically shows a non-limiting example of a representation of a block of machine code with indented branches.

FIG. 6 shows an example of a non-limiting software flowchart for illustrative purposes.

FIG. 7 schematically illustrates a non-limiting example of a representation of a block of machine code having marks that distinguish time complexity.

FIG. 8 shows an example of a non-limiting software flowchart for illustrative purposes.

FIG. 9 shows an example of a non-limiting software flowchart for illustrative purposes.

FIG. 10 shows an example of a non-limiting software flowchart for illustrative purposes.

FIG. 11 shows an example of the code sequence and the time calculation amount of this code sequence obtained by using the up-branch method.

FIG. 12 shows the code sequence of FIG. 11 and the time complexity of this code sequence obtained using the strongly connected subgraph method.

FIG. 13 shows the time complexity of this code sequence obtained using the combination of the code sequence of FIG. 11 and the upbranch method and the strongly connected subgraph method.

  The techniques described herein can be used in any type of computer or gaming system, including computer platforms, personal computers, network servers, stationary or portable video game machines, and any other type of device or configuration that has computing power. It is feasible. An example of a non-limiting implementation for purposes of illustration is described below, but other implementations are possible.

  FIG. 1 illustrates a non-limiting example of a hardware platform in which the present embodiment presented herein is implemented. The platform 100 includes a central processing unit (CPU) 101, a nonvolatile storage device such as a hard disk drive (HDD) 102 or a flash memory device, a random access memory (RAM) 103, a graphics processor 104, an input device interface 105, and a communication interface 106. including. The CPU 101 controls the platform while exchanging with other components via the common bus 107. The RAM 103 temporarily stores at least part of an operating system program and application programs executed by the CPU 101. In addition to software tools, the storage device 102 also stores an operating system (OS) and application programs (if any). Although one computer platform is shown in FIG. 1, a plurality of other computers may be connected to the network 40, and each computer may be configured in this embodiment as presented herein.

  The graphics processor 104 creates a video in response to a command from the CPU 101 and displays it on the screen 10. The input device interface 105 receives signals from external input devices such as a keyboard 20, a mouse 30, and game controllers 32 and 34. These input signals are supplied to the CPU 101 via the bus 107. The communication interface 106 allows the CPU 101 to exchange data with other computers over the network 40.

  FIG. 2 is a block diagram illustrating processing functions performed on the platform 100 configured in the present embodiment presented in this specification. More specifically, the platform 100 includes an editor 200, a plurality of source files 210, 211, 212, etc., a compiler or assembler 201, a plurality of object files 221, 222, 223, etc., a machine code editor 202, and a plurality of changed object files. , 231, 232, etc., linker 203, plural execution files 241, 242, 243, etc., disassembler 204, communication processor 205, etc.

  Source files 210, 211, 212 represent processing in the form of source code written in a programming language. The object files 221, 222, and 223 represent processing in the form of specific machine code that can be directly executed by the computer 100. The changed object files 231, 232, and 233 represent changes made by the user to the object files 221, 222, and 223, as will be described later. The execution files 241, 242, and 243 are changed machine code files created by combining one or more changed object files into one file. All the above files are stored in the storage device 102 and / or the RAM 103.

  The disassembler 204 converts the executable files 241, 242, 243 into assembly language “source” files 245, 247, 249, which in one implementation are binary (hexadecimal) machine instructions and It includes both assembly language "source" instructions that correspond one-to-one, and these "source" instructions are composed of opcode mnemonics, address labels, and function call labels.

  The user can write or edit the source code using the editor 200. For example, a user such as a programmer enters a set of instructions in a suitable programming language such as C ++ language. Then, he / she gives a save command to the editor 200, and the editor 200 writes the resulting source file into the storage device 102.

  The compiler 201 receives a source file and generates machine code. This is done by accessing the storage device 102, reading a source file written by the programmer, parsing each line of the source code in the file, and converting the source code into machine code understandable by the computer 100. This process is known as compilation, and the output of the compilation is called object code. The compiler 201 stores the compiled object code in the storage device 102 as an object file.

  Subsequently, according to this embodiment presented in this specification, a user such as a programmer confirms the machine code created by the compiler 201, and in some cases, the machine code and corresponding high-level source code can be changed. There is an option to do so that a modified version of the machine code, such as the modified object files 231, 232, 233, etc. will be presented in a more readable manner for future review, possible debugging, and / or possible modification. Become. These modification techniques presented herein help the user to better understand the machine code output from the compiler not only in terms of its computational complexity, but also in terms of its flow. It also helps the user understand how to compile.

  The linker 203 accesses the storage device 102 and reads one or more changed object code files created by the user. Linker 203 then edits some parts to combine these modified object code files into a single load module and organizes them into a consistent set of instructions with resolved absolute and relative addresses. This process is known as linking. The linker 203 stores these execution files 241, 242, and 243 in the storage device 102.

  The communication processor 205 communicates with any of a source file, an object file, a modified object file, an execution file, and an assembly language file in addition to other computers in the network 40.

  As described above, a machine code is a set of instructions that are executed directly by a central processing unit (CPU) of a computer. In general, machine code is very difficult for most people to read and understand. These computer instructions may be thought of as the lowest level representation of a compiled computer program and / or assembly computer program, and may correspond one-to-one with the CPU execution target. Each processor family has its own set of machine code instructions. These instructions correspond to different commands for the machine.

  In the machine code instruction set, the length of all instructions may be the same, or the length of the instructions may be variable. Most instructions have one or more fields that allow basic instruction types (e.g., in addition to actual operations (e.g., addition or comparison), addressing modes, addressing offsets, or actual values themselves). Arithmetic, logic, jumps, etc.) are also specified.

  FIG. 3 illustrates an example non-limiting software flowchart for purposes of illustration of a method for modifying machine code to enhance human understanding according to the present example presented herein. First, in step S1, the computer 100 receives, for example, C language source code written and input by the user. Subsequently, in step S2, the compiler 201 of the computer 100 compiles the received source code into machine code (or the compiler 201 creates intermediate assembly language code, which is then converted into machine code by an assembler (not shown). May be) The user receives the machine code (step S3), examines it, and changes the program as appropriate using one of the methods described below (step S4). The computer 100 receives the changed code, generates an execution file via the linker 203 (step S5), and outputs it as an output code in step S6.

  According to one embodiment, code review and changes that result in an understanding of the instruction flow are supported in three main ways:

(Branch with arrow annotation in machine code)
Machine code branch instructions usually only specify the offset or address of the branch destination. Since tracking the branch destination requires particularly mental effort, the machine code may be simplified by drawing an arrow from the branch to the branch destination instruction. Considering that some branches are associated with previous machine instructions and some are associated with subsequent machine instructions, these arrows can be organized regularly.

  In one embodiment, all forward / downward branch arrows appear on the left side of the code and all backward / upward branch arrows appear on the right side of the code. By presenting in this way, the arrow has a regular counterclockwise flow as shown in FIG. For example, as can be seen in FIG. 4, there are four forward / downward branch arrows on the left side of the code, and two backward / upward branch arrows on the right side of the code.

  Further, arrows having the same branch destination may be merged in the vertical direction to reduce the number of congestions and arrows. For example, these arrows may be drawn to have a common longitudinal section.

  In order to maintain regular code presentation, the branch that is closer to the branch should be placed closer to the code than the arrow that is farther away. For example, as can be seen in FIG. 4, on the left side of the code, the branch whose branch destination is “cmplw r9, r5” is longer than the branch whose branch destination is “cmplw r8, r4”, so the latter branch is drawn closer to the code. ing.

  In this embodiment, the branch back to and from other functions in the code is most preferably represented by a single horizontal arrow or double arrow. For example, a branch that connects to other functions in the code is represented by a single horizontal double arrow pointing to the right of the instruction, and a return branch is represented by a single horizontal right arrow pointing to the right of the instruction. (See the arrow pointing to the right of the last instruction line in the code of FIG. 4).

(Branch with indentation annotation in machine code)
Typically, machine code does not include indentation (but high-level languages often include indentation). In other words, all command lines are aligned vertically. This format does not provide visual insight when tracking program flow. It is therefore desirable to make this possible based on the logical block of code for an apparent understanding. In the preferred embodiment, all machine instructions are repeated sequentially.

  In one embodiment, when a downward branch in a function is encountered, the branch destination is marked with an indentation freeze symbol (note that this line should not be further indented). For example, as can be seen in FIG. 5, a downward branch in the function is encountered on the third line, and the branch destination line 28 is marked with an indentation freeze symbol such as “*”. Similarly, the lines 15, 17 and 25 corresponding to the branch destinations of the downward branch are also marked with indentation freeze symbols.

  In this example, when an upward or downward branch in a function is encountered, all subsequent lines are indented until an indentation freeze symbol is encountered or the end of the function is reached. Then, the process is resumed at the line following the branch. For example, in the code representation of FIG. 5, because a branch is encountered at line 2, subsequent line 3 is indented, and each subsequent line is indented until an indentation freeze symbol is encountered at line 28. This indentation emphasizes the importance of the code following the branch instruction.

  FIG. 6 shows an example of an indentation algorithm, and according to this, the indentation level of each machine instruction is incremented by one tab unless it is a branch destination of a branch instruction.

  First, all machine instructions are initialized so that the indentation level becomes zero (step S10). The algorithm then follows a list of all machine instructions in the code from start to finish. For example, in the code shown in FIG. 5, the algorithm considers all machine instructions from the first “line 10,0” to the last “blr”. Next, the algorithm determines whether a branch machine instruction has been encountered (step S12). If the answer is negative, the algorithm returns and continues to follow the list of machine instructions. On the other hand, if the answer is affirmative, the algorithm determines whether the encountered branch is a downward branch (step S14). If the answer to the determination is negative, the algorithm proceeds to step S15A (described later). If the answer is affirmative, the algorithm marks the branch destination of the branch with a freeze token in the machine instruction under consideration (step S15) and proceeds to the next step.

  After marking with a freeze token in a machine instruction that specifies the branch destination of a downward branch, in step S15A, the algorithm follows a series of subsequent machine instructions while incrementing the indentation level of each line. As each machine instruction ends, the algorithm determines whether a freeze token has been encountered (step S17). If the answer is no, the algorithm proceeds to step S16. On the other hand, if the answer is affirmative, the algorithm does not increment the indentation level of the machine instruction line and returns to step S12 (assuming that the current line number is not the last line number, see steps S12A and S12B). Finally, the algorithm determines whether the machine instruction is the last in the list of all machine instructions (step S12A). If so, the algorithm ends (step S20). If not, the current line number is incremented and the process returns to step S12.

  An application example of the indentation algorithm of FIG. 6 is shown in FIG. The first instruction line that encounters a downward branch is the third line. Therefore, the branch destination of that line is marked with a freeze token, and the next line (line 3) is indented by one tab, and each subsequent line has a freeze token at line 28 To inline 28. Subsequent lines 5-11 following line 4 are indented and the process continues until the last line "blr" (return branch represented by a single horizontal right arrow pointing to the right of the instruction) is reached. To do. In other embodiments, only unconditional branching is considered when placing freeze symbols or indenting. This makes the appearance slightly different / more understandable.

(Block with time complexity annotation using upbranch method in machine code)
In other embodiments, each line of machine code can be marked with a visual indicator that represents an estimate of the time complexity resulting from the branch. This is yet another way of visually distinguishing important features and program flow as a result of branching. In typical machine code, if there are a large number of loops in the code, the programmer cannot quickly read and understand the computational complexity of the line or block of lines.

For example, code that does not contain any loops is determined to have a constant execution time and is typically represented as O (1) in big O notation. On the other hand, a code composed of a single loop is determined to have a time calculation amount of order n or O (n), where n is an arbitrary number of times the loop can be executed. Further, if a code loop exists within another code loop, that is, if the code has a nested loop, the inner code loop determines that the time complexity is of order n ² or O (n ² ). Is done. At this time, the outer loop can be executed n times and the inner loop can be executed n times per outer loop, so that the inner loop is repeated a total of n × n times. Similarly, in a triple loop consisting of a code loop within a code loop within a code loop, the time complexity of the innermost loop is of the order n ³ or O (n ³ ).

For example, as shown in FIG. 7, a block composed of an instruction line between the third line and the penultimate line is composed of a single loop, and is represented by O (n). On the other hand, a block composed of rows between row 4 and row 26 is composed of loops in other loops, and is represented by O (n ² ).

Informing the time complexity of each line of code helps to understand the structure and flow of the code, so each important time complexity section is visually highlighted with a highlighted color or other visual indication. It may be marked. As an example of this technique, as shown in FIG. 7, for example, the section of the code with the time complexity O (1) is white, the section of the code with the time complexity O (n) is yellow, and the time The sections of the code with O (n ² ) complexity are orange and colored (generally patents are not color printed, so these different colors are represented by shading). As another embodiment, a code whose time calculation amount is deteriorated is colored with a single color gradation of a specific color.

For example, as shown in FIG. 7, a section whose calculation amount is level O (n) is expressed in yellow (light shading), for example, and a section whose calculation amount is level O (n ² ) is orange (intermediate shading), for example. ).

  In addition to specifying the time complexity of each entire block of machine code instructions, in one embodiment, the time complexity of individual machine code instructions is also specified.

In machine code, a loop can be determined by a machine code instruction that branches conditionally or unconditionally to the previous machine code instruction. This loop is a set of all machine code instructions represented between the branch destination of the machine code branch and the machine code branch itself. The time complexity of a machine code instruction can be determined by the maximum number of loops in which this machine code instruction resides, with the requirement that the loop must be fully contained in order to exist in another loop. If the machine code instruction is not in any loop, the time complexity is O (1). If the machine code instruction exists in only one loop, the time complexity is O (n). If the machine code instruction exists in two loops (loops within a loop), the time complexity is O (n ² ). If machine code instructions are present in three loops (loops within a loop), the time complexity is O (n ³ ). This definition of the time complexity of machine code instructions continues indefinitely according to a certain pattern.

  An example of a non-limiting upbranch method presented herein provides a heuristic approach to estimating time complexity based on the inline order in which the code is written. Human programmers often write code in an order that reflects nesting. For example, if a piece of code contains an entry point, followed by a number of in-order instructions, followed by a loop and returning to the entry point, this human programmer makes the in-order instruction part of the loop I can guess what I intended. This assumption is not always true, but there may be instructions or code fragments in the block of code that are accessed only slightly from other parts of the code or never accessed. Is not part of the loop. Nevertheless, when a programmer writes code that defines instructions in a loop, it is likely that such instructions will be executed as many times as the loop executes, so essentially this loop belong to. Thus, the up-branch method provides a heuristic analysis that can be useful for inferring instructions belonging to a loop based on the order in which the programmer wrote these instructions. Furthermore, in many cases, the accuracy of the upbranch method can be confirmed by executing a different heuristic method on the same code and detecting a situation in which the time calculation amount by the upbranch method is not accurate.

FIG. 8 shows an example of a non-limiting algorithm, and the time calculation amount of a certain machine code instruction in the function is determined according to this (referred to as an up-branch method). Hereinafter, various calculation amount levels are represented by zero = O (1), 1 = O (n), 2 = O (n ² ), 3 = O (n ³ ), and the like.

  First, in step S30, the algorithm initializes all machine code instructions so that the time complexity is zero. Next, a list of all conditional branches or unconditional branches that branch to the previous instruction is constructed (step S31), and then, the list of all upward branches is started from the smaller number of machine code instructions to be skipped. Sort to the larger one (step S32). Then, the algorithm loops through a list of all upward branches (step S33), and for each branch, obtains the maximum time calculation amount that the branch can represent assuming that the branch represents one time calculation amount (step S34). The maximum amount of time for branching is determined by the flowchart of FIG. Subsequently, the algorithm loops through all machine code instructions starting from the branch destination and ending with the machine code branch itself (step S35), and the maximum amount of time represented by this branch is If it is larger than the stored time calculation amount, the maximum time calculation amount represented by this branch is stored as a new time calculation amount relating to this machine code instruction (step S36), and the process is terminated (step S37).

  Further, the following algorithm shown in FIG. 9 can determine the maximum time complexity for a certain branch given an initial complexity (pseudo code described at the end of the specification).

  For that branch, the algorithm loops through all branches that skip more instructions than this branch (step S40), and if in step S41 the branch is completely contained within the branch under consideration in this iteration, The computational complexity is equal to the larger of the current computational complexity and the computational complexity of the branch under consideration in this iteration (determined by recursively calling this algorithm with the current computational complexity). Finally, in step S42, the algorithm returns the value of the calculation amount and ends (step S43).

(Annotated line with time complexity using strongly connected subgraph method in assembly code)
In one embodiment, the following algorithm (referred to as a strongly connected subgraph method) detects the rough time complexity in the worst case of assembly code instructions. This method is based on the code flow and the branch destination of the branch instruction. It is possible to detect the time calculation amount replaced with O (n ^p ).

  FIG. 10 shows an example of a non-limiting algorithm, and the time complexity of an assembly code instruction is determined accordingly.

(Create code flow graph)
First, in step S50, a code flow graph is created. More specifically, a directed graph in which each line of the assembly code is used as a node and these nodes are connected according to the control flow of the program is created. For example, in the case of an assembly program consisting of three lines, since the code flow usually proceeds from one line to the next, the corresponding code flow graph is {1 → 2, 2 → 3, 3 → null}. Become. If the first code instruction is a conditional jump to line 3, the new graph will be {1 → 2, 1 → 3, 2 → 3, 3 → null}.

(Identifies each strongly connected subgraph)
Next, in step S51, the algorithm identifies each strongly connected subgraph. A depth-first search is performed from the start node to identify all strongly connected subgraphs of the code flow graph. A strongly connected subgraph is any node or any group of nodes that form a cycle. More precisely, nodes A and B form a strongly connected subgraph if there is a path from A to B and a path from B to A (ie, a closed circuit is formed). A strongly connected subgraph is identified during a depth-first search if the next node to be searched is a node already included in the current scan. The strongly connected subgraph thus identified is recorded starting from a node found to be included in the current scan (referred to as a root node) up to the last node of the current search scan. For example, when the path {1, 2, 3, 4, 5, 2} is searched in the depth-first search, the strongly connected subgraph {2, 3, 4, 5} is recorded, and the last node of the previous scan is Continue the depth-first search as if it were a leaf (a terminal node with no children). If two or more strongly connected subgraphs are the same, only one of these identical strongly connected subgraphs is retained.

(Create a set of strongly connected subgraphs)
After identifying each strongly connected subgraph, in step S52 they are placed in various sets that share the same root node. For example, the strongly connected subgraphs {2, 3, 4} and {2, 3, 5} have the same root node 2 and are therefore included in the same set.

  Before adding a strongly connected subgraph to the set, it is checked whether this strongly connected subgraph is a subset of the other strongly connected subgraphs in this set. A graph that is a subset of another graph is defined as the same graph as a continuous portion of another graph. For example, the graph {2, 3, 4} is a subset of the graph {2, 3, 4, 5}. If this strongly connected subgraph is a subset of another strongly connected subgraph in this set, it is not added to this set, but conversely in another suitable set that has the same root node and is in that set It is added on condition that it is not a subset of any strongly connected subgraph. If a strongly connected subgraph cannot be added to any set, this particular strongly connected subgraph defines a unique set.

(Create a set graph)
After various sets of strongly connected subgraphs are created, in step S53, new set graphs of these sets are constructed using the following algorithm.

  A set C1 has a root node contained in another strongly connected subgraph in a different set C2, and any strongly connected subgraph in C2 is not a subset of the strongly connected subgraph in C1 (node C1 is defined as a child of C2, for example, C2 → C1. For example, if set C1 contains {3, 4, 5} and set C2 contains {2, 3, 4}, C1 is a child of C2. As a further example, if set C3 contains {2,3} and set C4 contains {3,2,4}, C3 is a child of C4, but C4 is not a child of C3 (C3 is a C4 child) Because it is a subset). Once the graph is complete, for each set of nodes C1 and C2 where C1 is a child of C2 and C2 is a child of C1, these nodes are disconnected from each other.

(Analysis of the longest path of each node in the set graph)
Next, in step S54, the longest path in the set graph is analyzed. Using the newly created set graph of these sets, the longest number is obtained when each node is scanned backwards until a node having no parent is reached. For example, if C1 → C2, C1 → C3, C2 → C3, C1 is the only node that has no parent and the scan cost is zero, and C2 has a scan cost of 1 (one node scan to reach C1) C3 has a scanning cost of 2 (two nodes are scanned to reach C1 via C2).

(Sort set)
Subsequent to the identification by node scanning in step S54, in step S55, a sorted list L of sets is created from the smaller number to the larger number using the number of node scans as a reference.

(Allocate time calculation)
Next, in step S56, a time calculation amount (for example, natural numbers 0, 1, 2,..., P) is assigned to each node (that is, each line of the code). First, the time complexity is initialized to zero for each line of code. Then, for each set of sorted list L, the time complexity of each individual line of code (in each strongly connected subgraph of this set) is assigned as the value of node scan plus one.

(Replace time calculation)
Finally, in step S57, the calculation amount of this row is expressed in the big O notation as follows according to the time calculation amount assigned to each row.
0 → O (n ⁰ ) = O (1)
1 → O (n ¹ ) = O (n)
2 → O (n ² )
3 → O (n ³ )
4 → O (n ⁴ )
...
p → O (n ^p )
The program ends (step S58)

(Example)
Using the above-described strongly connected subgraph method, for example, the time complexity can be detected for an example of the following assembly code program.
Example assembly program # 1
1: Do work
2: Do work
3: Do work
4: Conditionally branch to line 3
5: Conditionally branch to line 7
6: Do work
7: Conditionally branch to line 2
8: Do work
Step 1: Create a code flow graph
1 → 2
2 → 3
3 → 4
4 → 3, 4 → 5
5 → 6, 5 → 7
6 → 7
7 → 2, 7 → 8
8 → null
Step 2: Identify strongly connected subgraphs
1
1,2
1,2,3
1,2,3,4
1,2,3,4, (3) Found
strongly connected subgraph: 3,4
1,2,3,4,5
1,2,3,4,5,7
1,2,3,4,5,7, (2) Found
strongly connected subgraph: 2,3,4,5,7
1,2,3,4,5,7,8
1,2,3,4,5,6
1,2,3,4,5,6,7
1,2,3,4,5,6,7 (2) Found
strongly connected subgraph: 2,3,4,5,6,7
1,2,3,4,5,6,7,8
List of all strongly connected subgraphs:
2,3,4,5,6,7
2,3,4,5,7
3,4
Step 3: Create collections of strongly connected
subgraphs (creates a set of strongly connected subgraphs)
Collection A:
3,4
Collection B:
2,3,4,5,6,7
2,3,4,5,7
Step 4: Create a collection graph
B → A
Step 5: Analyze the longest path in collection
graph (analyze the longest path in a set graph)
Collection A: 1
Collection B: 0
Step 6: Sort collections
Collection B: 0
Collection A: 1
Step 7: Assign time complexity
Ten
twenty one
3: 2
4: 2
5: 1
6: 1
7: 1
8: 0
Step 8: Interpret time complexity (replaces time complexity)
1: O (1)
2: O (n)
3: O (n ² )
4: O (n ² )
5: O (n)
6: O (n)
7: O (n)
8: O (1)

Example assembly program # 2
1: Do work
2: Conditionally branch to line 1
3: Conditionally branch to line 1 (conditionally branch to line 1)
4: Do work
Step 1: Create a code flow graph
1 → 2
2 → 3, 2 → 1
3 → 4, 3 → 1
4 → null
Step 2: Identify strongly connected subgraphs
1
1,2
1,2, (1) Found
strongly connected subgraph: 1,2
1,2,3
1,2,3, (1) Found strongly
connected subgraph: 1,2,3
1,2,3,4
List of all strongly connected subgraphs:
1,2
1,2,3
Step 3: Create collections of strongly connected
subgraphs (creates a set of strongly connected subgraphs)
Step 3a: Collection A:
1,2
1,2,3
Step 3b: Collection A:
1,2,3

Collection B:
1,2 (was
a subset of {1,2,3} in collection A) (It was a subset of {1,2,3} of set A)
Step 4: Create a collection graph
A → B
Step 5: Analyze the longest path in collection
graph (analyze the longest path in a set graph)
Collection A: 0
Collection B: 1
Step 6: Sort collections
Collection A: 0
Collection B: 1
Step 7: Assign time complexity
1: 2
twenty two
3: 1
4: 0
Step 8: Interpret time complexity (replaces time complexity)
1: O (n ² )
2: O (n ² )
3: O (n)
4: O (1)
Example assembly program # 3
1: Conditionally branch to line 3
2: Conditionally branch to line 4
3: Conditionally branch to line 2 (conditionally branch to line 2)
4: Conditionally branch to line 3
Step 1: Create a code flow graph
1 → 2, 1 → 3
2 → 3, 2 → 4
3 → 4, 3 → 2
4 → 3, 4 → null
Step 2: Identify strongly connected subgraphs
1
1,3
1,3,2
1,3,2,4
1,3,2,4, (3) Found strongly connected subgraph: 3,2,4
1,3,2,
(3) Found strongly connected subgraph: 3,2
1,3,4
1,3,4, (3)
Found strongly connected
subgraph (found strongly connected subgraph): 3,4
1,2
1,2,4
1,2,4,3
1,2,4,3,
(2) Found strongly connected subgraph: 2,4,3
1,2,4,3,
(4) Found strongly
connected subgraph: 4,3
1,2,3
1,2,3,
(2) Found
strongly connected subgraph: 2,3
1,2,3,4
1,2,3,4, (3) Found
strongly connected subgraph: 3,4
List of all strongly connected subgraphs
(eliminating any duplicates) (list of all strongly connected subgraphs (exclude any duplicates)):
3,2,4
3,2
3,4
2,4,3
4,3
2,3
Step 3: Create collections of strongly connected
subgraphs (creates a set of strongly connected subgraphs)
Step 3a:
Collection A:
2,3
2,4,3
Collection B:
3,2
3,2,4
3,4
Collection C:
4,3
Step 3b:
Collection A:
2,4,3
2,3
Collection B:
3,2,4
3,4
Collection C:
4,3
Collection D:
3,2 (was
a subset of {3,2,4} in collection B) (It was a subset of {3,2,4} of set B)
Step 4: Create a collection graph
Step 4a:
A → B
B → C
A → D
B → A
B → C
B → D
C → D
Step 4c:
A → B, B → A Break
both connections between A and B
A → C
A → D
B → C
B → D
C → D
Step 5: Analyze the longest path in collection
graph (analyze the longest path in a set graph)
Collection A: 0
Collection B: 0
Collection C: 1
Collection D: 2
Step 6: Sort collections
Collection A: 0
Collection B: 0
Collection C: 1
Collection D: 2
Step 7: Assign time complexity
Ten
twenty three
3: 3
4: 2
Step 8: Interpret time complexity (replaces time complexity)
1: O (1)
2: O (n ³ )
3: O (n ³ )
4: O (n ² )

(Combination of time complexity detection algorithms)
In the present application, the up-branch method and the strongly connected subgraph method are disclosed as two methods for calculating the time complexity. In addition to these differences, the advantages and disadvantages are listed below.
In the up-branch method, due to the nature of the algorithm grouping based on the line number, the time complexity of this line of code is incorrect when there is a possibility that the line of code is not actually part of the cycle. (See assembly program example No. 4).
The up-branch method is conservative and does not recognize that it contains a cycle if the first or last line of code is shared between multiple cycles, and some cycles are part of other cycles with respect to row numbers Even when they overlap each other, it is not recognized that a cycle is included (see assembly program example No. 5).
The strongly connected subgraph method actively recognizes that it contains a cycle even if the source code or assembly code may not actually result in this time complexity. This is because the actual computation of each line of code that does branching is not analyzed. This also reduces the accuracy of the time calculation amount, so that a calculation amount such as O (log n) cannot be obtained.
In the strongly connected subgraph method, the time complexity of a line of code is never judged smaller than the theoretically possible time complexity, so all the time complexity calculated is the maximum value.

In view of the above advantages and disadvantages of the time complexity algorithm based on the upbranch method and the time complexity algorithm based on the strongly connected subgraph method, it is advantageous to take the following measures.
-Determine the theoretically possible worst-time complexity using the strongly connected subgraph method.
The minimum time complexity of each line of code is selected from either the up-branch method or the strongly connected subgraph method (see assembly program examples No. 4 and No. 5). Thereby, while estimating the time calculation amount conservatively, any erroneous time calculation amount larger than the actual one existing in the upbranch method is excluded.

(Other examples)
Using the two methods disclosed above to calculate the time complexity, the results were compared for the following two example assembly programs.

Example assembly program # 4
1: Conditionally branch to line 3
2: Unconditionally branch to line 4 (this code
line is not in a cycle) (unconditionally branch to line 4 (the line of this code is not in a cycle))
3: Conditionally branch to line 1 (conditionally branch to line 1)
4: Do work

Up Branch Method of computing time complexity:
1: O (n)
2: O (n)
3: O (n)
4: O (1)

Strongly connected subgraph method of computing
time complexity (strongly connected subgraph method for computing time complexity):
1: O (n)
2: O (1)
3: O (n)
4: O (1)

Minimum between each time complexity method
(conservative with no errors) (minimum value of each time calculation method (moderate and error-free))
1: Min ((O (n), O (n)) = O (n)
2: Min ((O (1), O (n)) = O (1)
3: Min ((O (n), O (n)) = O (n)
4: Min ((O (1), O (1)) = O (1)
Example assembly program # 5
1: Conditionally branch to line 3
2: Unconditionally branch to line 5 (this code
line is not in a cycle) (unconditionally branch to line 5 (the line of this code is not in a cycle))
3: Conditionally branch to line 1 (conditionally branch to line 1)
4: Conditionally branch to line 1
5: Do work

Up Branch Method of computing time complexity:
1: O (n)
2: O (n)
3: O (n)
4: O (n)
5: O (1)

Strongly connected subgraph method of computing
time complexity (strongly connected subgraph method for computing time complexity):
1: O (n ² )
2: O (1)
3: O (n ² )
4: O (n)
5: O (1)

Minimum between each time complexity method
(conservative with no errors) (minimum value of each time calculation method (moderate and error-free))
1: Min ((O (n), O (n ² )) = O (n)
2: Min ((O (1), O (n)) = O (1)
3: Min ((O (n), O (n ² )) = O (n)
4: Min ((O (n), O (n)) = O (n)

4: Min ((O (1), O (1)) = O (1)

  FIG. 11 and FIG. 12 show examples of complex code sequences and corresponding time complexity analysis results obtained using the up-branch method and the strongly connected subgraph method, respectively. More specifically, FIG. 11 shows an example of a code sequence and the time calculation amount of this code sequence obtained using the up-branch method. FIG. 12 shows the exact same code sequence and the time complexity results obtained using the strongly connected subgraph method. As can be seen in FIG. 11 and FIG. 12, these two methods differ in nature, approach to cycle detection, etc., so the values for the time complexity measure of some lines of code are different. Therefore, as described above, the two methods may be combined by selecting the scale of the minimum time complexity of each line of the code from either the up-branch method or the strongly connected subgraph method. This is shown in FIG. This represents a conservative estimate of the time complexity, and excludes any erroneous time complexity that is larger than actual due to the up-branch method.

  In the following, an additional example of implementation of a non-limiting algorithm for illustrative purposes will be described.

A graphical arrow extending from a branch machine instruction line to a branch machine instruction line,
a. Multiple downward branches appear on the left side of the machine code,
i. A horizontal line connected to ii in the row that is the source of the branch;
ii. A vertical line connected to iii, progressing downward from the horizontal line to the branch instruction line;
iii. Consisting of a horizontal line with a right-pointing arrow pointing to the branch destination instruction at the branch destination of the branch,
b. Multiple upward branches appear on the right side of the machine code,
i. A horizontal line connected to ii in the row that is the source of the branch;
ii. A vertical line connected to iii, progressing upward from the horizontal line to the branch instruction line;
iii. Consisting of a horizontal line with a left-pointing arrow pointing to the branch destination instruction at the branch destination of the branch,
c. When there are interleaved machine instructions that branch downward and upward relatively close to each other, the downward and upward branches are combined to form a counterclockwise flow;
d. Branches that share a common branch destination are optionally drawn with their vertical lines overlapping each other,
e. Branches that do not share a common branch destination are drawn so that their vertical lines do not overlap each other,
f. A branch with a closer branch destination should have a vertical line located closer to the code than a branch with a farther branch destination;
g. A branch that joins another function is represented by a single horizontal double arrow pointing to the right of the instruction,
h. A return branch is a graphical arrow, represented by a single horizontal right arrow pointing to the right of the instruction.

Machine instructions following a branch machine instruction are indented one tab according to the following algorithm, unless they are the branch destination of a branch instruction.
a. Initialize all machine instructions so that the indentation level is zero.
b. Follow the machine instruction list from beginning to end.
c. If a branch machine instruction is encountered, do the following:
i. If the branch is downward, mark that branch with a freeze token.
ii. Follow a series of machine instructions, incrementing the indentation level of each line.
iii. If a freeze token is encountered, the indentation level for that line is not incremented, step c is stopped, and step b is continued.

Computer time complexity is an important property of code and can be visualized by visually showing each block of code with a corresponding time complexity. The time complexity of all machine code instructions in the function is zero = O (1), 1 = O (n), 2 = O (n ² ), 3 = O (n ³ ), etc. Can be determined by algorithm.
a. Initialize all machine code instructions so that the time complexity is zero.
b. Build a list of all conditional or unconditional branches that branch to multiple previous instructions.
c. Sort the list of all previous branches from the smallest number of machine code instructions to skip to the largest.
d. Loop through the list of all previous branches.
i. For this branch, the maximum time calculation amount that can be represented by the branch is calculated assuming that the branch represents a time calculation amount of one.
ii. Loop from all machine code instructions starting at the branch destination and ending at the machine code branch itself.
a. If the maximum time complexity represented by this branch is greater than the previously stored time computation associated with this machine code instruction, the maximum time computation represented by this branch is stored as a new time computation associated with this machine code instruction.

The following algorithm can determine the maximum amount of time complexity for a branch given the initial complexity (pseudocode that follows the specification).
a. Given a list of all conditional or unconditional branches that branch to the previous instruction, sort from the smaller number of machine code instructions to skip.
b. For that branch, loop over all branches that have more instructions to skip than this branch.
i. If the branch is completely contained within the branch under consideration in this iteration,
a. The computational complexity is equal to the larger of the current computational complexity and the computational complexity of the branch under consideration in this iteration (determined by recursively calling this algorithm with the current computational complexity).
c. Returns the amount of computation.

An example of the source code for the markup time complexity algorithm by the upbranch method is shown below.

  By visually converting the machine code or assembly code using the method disclosed above, it becomes easier for a user such as a programmer to review and understand, and in some cases, it can be corrected for the purpose of speed improvement. These methods can be used in machine code created by any type of compiler, and the disclosed method is not limited to computers, and can be used in conjunction with any type of machine having computing power.

  Although the technology herein has been described with reference to non-limiting examples for purposes of illustration, the present invention is not limited to this disclosure. The present invention is defined by the claims, and is intended to cover all corresponding and equivalent configurations, whether or not specifically disclosed herein.

Claims (25)

A method for detecting a time complexity associated with an executable program stored in a memory device of a computer comprising:
(1) automatically analyzing the stored program by a computer processor and detecting a time calculation amount of the program based on a loop in the code;
(2) automatically analyzing the stored program by the processor and detecting a time calculation amount of the program based on a flow of the code in the program and a branch destination of a branch instruction;
And automatically determining a minimum time calculation amount of the time calculation amount detected in (1) and the time calculation amount detected in (2) as the time calculation amount of the program. A non-transitory computer readable storage medium storing an executable machine code program, the program instructing a microprocessor to execute a sequence of steps, wherein the program represented graphically includes a plurality of programs With machine instruction lines,
A graphical arrow extends from the branch machine instruction line to the branch machine instruction line,
a. The arrow corresponding to the downward branch appears on the left side of the machine code, and
The horizontal line starting from the branch source line, wherein the horizontal line is connected to a vertical line that progresses downward from the horizontal line to the instruction line of the branch destination, and the vertical line is the branch destination at the branch destination of the branch With a horizontal line connected to a horizontal line with a right-pointing arrow pointing to
b. The arrow corresponding to the upward branch appears on the right side of the machine code,
A horizontal line starting from a branch source line, wherein the horizontal line is connected to a vertical line progressing upward from the horizontal line to the instruction line of the branch destination, and the vertical line is the branch destination at the branch destination of the branch A storage medium comprising a horizontal line connected to a horizontal line having a left-pointing arrow pointing to the instruction.   The non-transitory computer of claim 2, wherein the combination of downward and upward branches has a counterclockwise flow when there are alternating machine instructions that branch downward and upward relatively close to each other. A readable storage medium.   The branches that share a common branch destination are drawn such that their vertical lines overlap each other, and the branches that do not share a common branch destination are drawn so that their vertical lines do not overlap. A non-transitory computer-readable storage medium.   The non-transitory computer-readable storage medium of claim 2, wherein a branch having a closer branch destination has a vertical line located closer to the code than a branch having a farther branch destination.   The non-transitory computer-readable storage medium of claim 2, wherein a branch coupled to another function in the code is represented by a single horizontal double arrow pointing to the right of the instruction.   The non-transitory computer readable storage medium of claim 2, wherein the return branch is represented by a single lateral right arrow pointing to the right of the instruction. A non-transitory computer readable storage medium storing an executable machine code program, the program instructing a microprocessor to execute a sequence of steps, wherein the program represented graphically includes a plurality of programs With machine instruction lines,
A non-transitory computer-readable storage medium in which a machine instruction immediately following a branch machine instruction is indented by one tab unless it is the branch destination of a branch instruction.   9. The non-transitory computer readable storage medium of claim 8, wherein when a downward branch in a function is encountered, the branch destination is marked with an indentation freeze symbol.   9. The non-transitory computer of claim 8, wherein upon encountering an upward or downward branch in a function, all subsequent lines are indented until an indentation freeze symbol is encountered or the end of the function is reached. A readable storage medium. A non-transitory computer readable storage medium storing an executable machine code program, the program instructing a microprocessor to execute a sequence of steps, wherein the program represented graphically includes a plurality of programs With machine instruction lines,
Each block of code is visually marked according to a corresponding time complexity, the time complexity including the number of loops in the code with which the block is associated in the program flow. A readable storage medium. The time complexity of a block having j loops where j is an integer greater than or equal to 0 is determined to be order n, and visually expressed in O (n ^j ) notation where n is an arbitrary number of times the loop is executed. The non-transitory computer readable storage medium of claim 11, which is marked.   The non-transitory computer-readable storage medium of claim 11, wherein each computational complexity section of the code is additionally visually marked by a visual display.   The non-transitory computer-readable storage medium of claim 13, wherein the visual indication includes a highlight color gradation.   The non-transitory computer of claim 11, wherein a time complexity of a machine instruction line is visually marked, and the time complexity indicates a maximum number of consecutive loops in which the machine instruction line exists. A readable storage medium. A method of detecting a time complexity associated with each instruction line of an executable machine code program, wherein each instruction line is visually marked according to a corresponding time complexity,
Creating a code flow graph such that nodes corresponding to individual lines of the code program are connected based on the control flow of the program;
Identifying a plurality of strongly connected subgraphs corresponding to any group of a plurality of nodes in the flow graph of the code forming a cycle;
Grouping the plurality of strongly connected subgraphs into a plurality of sets such that each strongly connected subgraph of a set shares the same root node;
Creating a set graph by constructing a directed graph of the plurality of sets based on whether a root node included in one set of the plurality of sets is included in another set; and
Analyzing the longest path in the set graph by finding the longest number when each node of each set is scanned backward without repeating the nodes until a node having no parent is reached;
Using the number of node scans in the analysis of the longest path to sort the sets by creating a sorted list of sets from the smallest to the largest;
Assigning a time complexity value p, where p = 0, 1, 2,... To each instruction line of code, based on the value of the node scan;
Assigning a time complexity measure O (n ^p ) for each line of the machine code program. A device that sets the machine code format of a computer to enhance the user's understanding of the basic flow of a program,
An editor that receives the source code entered by the user and generates a corresponding source file;
A compiler that receives the source file and generates an object file composed of machine code;
A machine code editor that receives the object file, changes the state of the object file, and creates a modified object file such that the graphically represented program is composed of a plurality of machine instruction lines;
A graphical arrow extends from the branch machine instruction line to the branch machine instruction line,
A machine instruction immediately following a branch machine instruction is indented by one tab unless it is the branch destination of a branch instruction,
A machine code editor, wherein each block of code is visually marked according to a corresponding time complexity, wherein the time complexity includes the number of loops in the code with which the block is associated in the flow of the program;
An apparatus comprising: a linker that receives the change object file and generates an execution file that is output as an output file. A method of formatting the machine code of a computer to enhance the user's understanding of the basic program flow,
Receiving the source code entered by the user in the editor and generating the corresponding source file;
Receiving the source file generated by the editor with a compiler and generating an object file composed of machine code;
The object file generated by the compiler is received by a machine code editor, the state of the object file is changed, and the changed object file is created so that the graphically represented program includes a plurality of machine instruction lines. There,
A graphical arrow extends from the branch machine instruction line to the branch machine instruction line,
A machine instruction immediately following a branch machine instruction is indented by one tab unless it is the branch destination of a branch instruction,
Each block of code is visually marked according to a corresponding time complexity, the time complexity comprising the number of loops in the code with which the block is associated in the flow of the program;
Receiving the modified object file generated by the machine code editor with a linker and generating an executable file to be output as an output file. A computer operating method that is executed by a computer processor accessing a non-transitory memory device that stores code and that estimates the time complexity of the code without the need to dynamically execute the code,
Determining a plurality of branches of the code;
Whether the first determined branch of the plurality of branches is completely included in other determined branches that have more instructions to skip than the first branch of the plurality of branches A step to check whether or not,
If the confirmation step confirms that the first branch is completely included, indicating an increased amount of time complexity associated with the first branch;
Recursively executing at least some of the steps described above for a plurality of further determined branches of the plurality of branches in the code to estimate a maximum time complexity of the code. The method that the processor performs.   The method of claim 19, wherein for each determined branch in the code, the execution step is performed recursively.   The plurality of branches includes a plurality of instructions, and the executing step includes a previously allocated time complexity value associated with the plurality of instructions and the indicated time associated with the plurality of branches. 20. The method of claim 19, wherein a time complexity is assigned for each of the plurality of instructions by comparing with a complexity.   The determining step comprises determining, in the ordered static list of codes, whether the plurality of determined branches branch to a plurality of previous portions of the ordered list. The method described.   The method of claim 19, wherein the determining step determines a plurality of branches in the code that branch in a predetermined direction.   24. The method of claim 23, wherein the predetermined direction includes upward.   20. The method of claim 19, further comprising displaying the estimated maximum time complexity on a display device to provide a human perceptible display.

Images