fig5 depicts a system outline relating to one embodiment of this invention . a scalability evaluation apparatus 100 is a computer with a single processor for evaluating the scalability of a parallel computer system 200 , and is connected to an output device 110 such as a printer or a display device . however , the scalability evaluation apparatus 100 may be a parallel computer . the scalability evaluation apparatus 100 includes a data obtaining unit 10 , a limit processing time calculator 11 and a scalability processor 12 . the scalability processor 12 has a scalability evaluation graph generator 21 , a scalability limit point judgment unit 22 and a scalability comparison unit 23 . the scalability evaluation apparatus 100 is connected to a log data storage 30 and a scalability limit point judgment data storage 40 . the parallel computer system 200 includes a measurement unit 201 . for example , the scalability evaluation apparatus 100 is connected to the parallel computer system 200 through a network . when the comparison of the parallel computer systems 200 is carried out , plural parallel computer systems 200 exist . in addition , the parallel computer system 200 can execute the same processing while changing the number p of processors . the measurement unit 201 of the parallel computer system 200 measures a parallel processing time γ i ( p ) of each processor i in a case of the number p of processors and a processing time τ i ( p ) of each processor i , while executing a parallel processing in accordance with a program . incidentally , a processing time χ i , j ( p ) of each parallel performance impediment factor j may be measured . for example , a time from a start to an end of each processing is measured by a timer , or a start time and an end time of each processing are recorded to compute a processing time by using them after the end of the processing . the measurement of the time may be performed by the software including the operating system ( os ) or hardware . data concerning the measured processing times is temporarily stored into a memory of the parallel computer system 200 , and may be stored into other storage devices such as a hard disk , according to circumstances . moreover , there is also a case where , instead of the measurement of the processing times , events of a program being executed are confirmed at predetermined time intervals , and the respective events are counted . such a measurement is called a measurement by sampling . although there is a difference due to the measurement accuracy , the method by the time measurement and the method by the sampling have the same result . fig6 depicts a conceptual view of the measurement by the sampling . fig6 depicts a manner that a time passes from the left to the right . in fig6 , a downward arrow indicates a timing of the sampling , and the sampling is carried out at predetermined time intervals as indicated by the intervals between the downward arrows . moreover , in fig6 , after a redundancy processing is first executed for χ i , red ( p ), a parallel calculation is carried out for γ i ( p ). incidentally , the processing is executed for τ i ( p ) as a whole . the number of times of the sampling is seven in the event of the redundancy processing continuing for χ i , red ( p ), and nine in the event of the parallel calculation continuing for γ i ( p ). during the entire processing time τ i ( p ), the number of times of the sampling is 22 . events other than the intentionally measured χ i , red ( p ) among the parallel performance impediment factors are collectively expressed by χ i , others ( p ), and it is understood that the number of times of the sampling during χ i , others ( p ) is 6 (= 22 − 9 − 7 ), by using the intentionally measured τ i ( p ), γ i ( p ) and χ i , red ( p ). incidentally , as described above , the processing time χ i , j ( p ) of the parallel performance impediment factor j is not always measured . however , because the general measurement by the sampling is described in the following , the measurement of the processing time χ i , j ( p ) of the parallel performance impediment factor j is also described . the summary of how to carry out the measurement actually by the sampling will be described below . ( a ) a flag for an event τ i ( p ) is turned on at a start of a processing , and is turned off at an end of the processing . at the time of execution , it is identified at predetermined time intervals whether the flag for the event τ i ( p ) is on / off , and the number of times that it is identified that the flag is on is counted to obtain the number of times of the sampling . a description and a processing in the following methods are combined as the need arises to measure the processing time . a programmer detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . in the case where a parallel language extension , a complier directive or the like is used , a tool interprets the parallel language extension , the complier directive or the like , and gives a description for turning the flag on / off . in the case where a parallel language extension , a complier directive or the like is used , a complier interprets the parallel language extension , the complier directive or the like , and gives a description for turning the flag on / off . a complier detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . an os detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . a runtime library detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . hardware detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . a description for a processing of discriminating that the flag is on and counting the number of times is given at a complier level . a description for a processing of discriminating that the flag is on and counting the number of times is given at an os level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a runtime library level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a hardware level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a tool level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a program level . a processing of discriminating that the flag is on and counting the number of times is executed at a hardware level . ( b ) an event is specified by a program name or an execution module name substituting for that , and at the time of execution , the program name or the execution module name is discriminated at predetermined time intervals , and the number of times that the name is discriminated is counted to obtain the number of times of the sampling . a name creation method in the following methods , a discrimination processing and a count processing are combined as the need arises to measure the processing time . a complier creates the program name or the execution module name . an os creates the program name or the execution module name . a runtime library creates the program name or the execution module name . hardware creates the program name or the execution module name . the program name or the execution module name is created by a description of a parallel language extension or a complier directive . the program name or the execution module name is created by a description of a programmer . a description for a discrimination processing of the created program name or execution module name and a count processing is given at a complier level . a description for a discrimination processing of the created program name or execution module name and a count processing is given at an os level . a description for a discrimination processing of the created program name or execution module name and a count processing is given at a runtime library level . a discrimination processing of the created program name or execution module name and a count processing is executed at hardware level . a description for a discrimination processing of the created program name or execution module name and a count processing is given at a tool level . a description for a discrimination processing of the created program name or execution module name and a count processing is given at a program level . a discrimination processing of the created program name , execution module name or the like and a count processing are executed at a hardware level . ( a ) each time an event χ i , j ( p ) or γ i ( p ) appears , a flag for that is turned on at the start of the processing , and the flag for that is set off at the end of the processing . it is assumed that at the time of execution , it is discriminated at predetermined time intervals whether a flag for each event is on / off , and the number of times that it is discriminated that the flag is on is counted to obtain the number of times of the sampling . since there is a case where the events χ i , j ( p ) and γ i ( p ) cannot be detected by one method , a description and a processing in the following methods are combined as the need arises to measure the processing time . a programmer detects the start and the end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . in the case where a parallel language extension , a complier directive or the like is used , a tool interprets the parallel language extension , the complier directive or the like , and gives a description for turning the flag on / off . in the case where a parallel language extension , a complier directive or the like is used , a complier interprets the parallel language extension , the complier directive or the like , and gives a description for turning the flag on / off . the complier detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . an os detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . a runtime library detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . hardware detects a start and an end of a processing in a program , that is , a position where the flag is to be turned on / off , and gives a description for turning the flag on / off . a description for a processing of discriminating that the flag is on and counting the number of times is given at a complier level . a description for a processing of discriminating that the flag is on and counting the number of times is given at an os level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a runtime library level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a hardware level . a description for a processing of discriminating that the flag is on and counting the number of times is given at a tool level . a description for a processing of discriminating that the flag is on and counting the number of times is given at an application program level . a processing of discriminating that the flag is on and counting the number of times is executed at a hardware level . ( b ) known module names are previously classified into a parallel processing or a processing portion relating to a parallel performance impediment factor , the module names are discriminated at the time of execution , and discrimination of the respective module names are counted to obtain the number of times of the sampling . a classifying method set forth below , a discrimination processing and a count processing are combined as the need arises to measure the processing time . a classification of module names is made at a complier level . a classification of module names is made at an os level . a classification of module names is made at a runtime library level . a classification of module names is made at a hardware level . a classification of module names is made at a parallel language extension or complier directive level . a classification of module names is made at a user level . a description for a discrimination processing of the module name and a count processing are given at a complier level . a description for a discrimination processing of the module name and a count processing are given at an os level . a description for a discrimination processing of the module name and a count processing are given at a runtime library level . a description for a discrimination processing of the module name and a count processing are given at a hardware level . a description for a discrimination processing of the module name and a count processing are given at a tool level . a description for a discrimination processing of the module name and a count processing are given at a program level . a description for a discrimination processing of the module name and a count processing are given at a hardware level . returning to the explanation of fig5 , the data obtaining unit 10 of the scalability evaluation apparatus 100 obtains respective processing times γ i ( p ) and τ i ( p ) ( according to circumstances , also χ i , j ( p )), which are measured as a processing time or a sampling count by the measurement unit 201 as described above , from the parallel computer system 200 , and stores them into the log data storage 30 connected to the scalability evaluation apparatus 100 . the limit processing time calculator 11 calculates the limit processing time τ lt ( p ), and stores the limit processing time with the corresponding processing time τ ( p ) into the scalability limit point judgment data storage 40 . incidentally , the limit processing time τ lp ( p ) can be calculated even in a case where the load is not balanced , when using the expression ( 2 ). on the other hand , in a case where it can be judged that the load is balanced , τ ( p )− γ j ( p ) (= χ j ), which is calculated by using the parallel processing time γ j ( p ) of the processor j whose processing time is τ ( p ), may be simply used as the limit processing time τ lt ( p ). when the processing times for all of the parallel performance impediment factors are measured , a result of accumulating all of the processing times for all of the parallel performance impediment factors may be used as the limit processing time τ lt ( p ). the second term indicates an average of the parallel processing times γ j ( p ). the limit processing time τ lt ( p ) may be calculated according to this expression . moreover , the processing content of the scalability processor 12 will be explained in details later . next , a processing flow of the system or the like explained in fig5 will be described by using fig7 . at first , a pre - processing is executed which includes a description for direct measurement of the processing times , a description for turning on / off a flag for counting the number of times of the sampling corresponding to each processing time by a complier , an os , a tool , a programmer , a runtime library , hardware or the like , and / or a classification of module names and the like for counting the number of times of the sampling corresponding to each processing time by the complier , the os , the tool , the programmer , the runtime library , the hardware or the like ( step s 1 ). there is a case where this processing is performed in the parallel computer system 200 or is performed in another computer system . further , there is also a case where a person such as a programmer performs it . incidentally , since the step s 1 is not a processing executed in the scalability evaluation apparatus 100 and the step s 1 may not be a processing executed in the parallel computer system 200 , it is depicted by a block of a dotted line . next , the measurement unit 201 of the parallel computer system 200 executes a measurement processing to measure the processing times or a measurement processing to count the number of times of the sampling on the basis of the pre - processing ( step s 3 ). the respective processing times γ i ( p ) and τ i ( p ) ( according to circumstances , also χ i , j ( p )) as measurement results , or count values of the sampling corresponding to the respective processing times are stored into the storage device of the parallel computer system 200 , and are read out by the data obtaining unit 10 of the scalability evaluation apparatus 100 . when obtaining the respective processing times γ i ( p ) and τ i ( p ) ( according to circumstances , also χ i , j ( p )) or the count values of the sampling corresponding to the respective processing times , the data obtaining unit 10 stores them into the log data storage 30 of the scalability evaluation apparatus 100 . incidentally , the measurement results with respect to the different numbers p of processors are stored into the log data storage 30 . furthermore , when comparing the parallel computer systems 200 with respect to the scalability , the measurement results of the plural parallel processing systems 200 are stored into the log data storage 30 . in addition , because the results are different according to the calculation size even when the configuration of the parallel computer system 200 dose not change , the parallel computer system 200 is treated as being different in the following , when the calculation size is different . then , the limit processing time calculator 11 identifies the processing time τ ( p ) for each number p of processors , for which the measurement result exists , from the respective processing times γ i ( p ) and τ i ( p ) ( according to circumstances , also χ i , j ( p )) or the count values of the sampling , which respectively correspond to the respective processing time , which are stored in the log data storage 30 , and calculates the limit processing time τ lt ( p ) according to the aforementioned expression , and stores the limit processing time τ lt ( p ) with the processing time τ ( p ) into the scalability limit point judgment data storage 40 ( step s 5 ). because the processing time τ ( p ) is the longest parallel processing time τ i ( p ) as described in the expression ( 1 ), the processing time τ ( p ) can be immediately identified . incidentally , when processing data concerning the plural parallel computer systems 200 , the step s 5 is carried out for each parallel computer system . for example , an example of data stored in the scalability limit point judgment data storage 40 is depicted in fig8 . in the example of fig8 , the depicted table includes a column of the number p of processors , a column of the processing time τ ( p ), a column of the limit processing time τ lt ( p ), a column of δτ lt ( p )/ δτ ( p ) and a column of a sign of the slope . however , data stored at the step s 5 is only data in the columns of the number p of processors and the processing time τ ( p ). in addition , although data at which the number p of processors is 1 is also represented in the example of fig8 , data of p = 1 is not always mandatory . because τ ( 1 ) may be a huge value , it may be impossible to measure it . according to this embodiment , τ ( 1 ) is not mandatory . next , the scalability evaluation graph generator 21 of the scalability processor 12 generates a scalability evaluation graph by using data stored in the scalability limit point judgment data storage 40 , and outputs the scalability evaluation graph to the output device 110 ( step s 7 ). an example of the scalability evaluation graph is depicted in fig9 . in the example of fig9 , a horizontal axis represents the processing time τ ( p ), and a vertical axis represents the limit processing time τ lt ( p ). in such a space , following relations are represented : a change ( i . e . a curve ) of a relation between the processing time τ ( p ) and the limit processing time τ lt ( p ) when the number p of processors is increased with respect to the calculation size n = 800 in a certain parallel computer system , a change ( i . e . a curve ) of the relation between the processing time τ ( p ) and the limit processing time τ lt ( p ) when the number p of processors is increased with respect to the calculation size n = 7200 and a change ( i . e . a curve ) of the relation between the processing time τ ( p ) and the limit processing time τ lt ( p ) when the number p of processors is increased with respect to the calculation size n = 51200 . in any cases , in the space , when the number p of processors is small , points representing the aforementioned relations are plotted in the lower right , and when the number p of processors is increased , the points are plotted toward the upper left , and when the number p of processors is increased despite the absence of the scalability , the points are plotted toward the upper right . incidentally , a 45 - degree line , which directs toward the diagonal upper right , is a limit line , and the points representing the relations are not plotted over this limit line to the diagonal upper left area . in the space as depicted in fig9 , the range that it can be said the scalability exists is a portion that the slope of the curve is equal to or less than 0 . on the other hand , the range that it can be said that the scalability does not exist is a portion that the slope of the curve is positive . therefore , the scalability limit point is a switching point from the portion that the scalability exists to the portion that the scalability does not exists . in view of fig9 , it is possible to find out the switching point that the slope of the curve changes from negative to positive . that is , it is possible to identify the limit point of the scalability . on the other hand , the larger the negative slope is , the worse the scalability is , and the smaller the negative slope is , the better the scalability is . moreover , fig9 is a diagram corresponding to fig1 to 4 . namely , the limit point of the scalability , which does not clearly indicate in fig1 to 4 , is clarified . in addition , also in the diagram like fig1 , the slope becomes vague and the evaluation of the scalability is also vague when there is no data of τ ( 1 ), and the scalability evaluation is difficult because it is impossible to draw the diagram like fig2 when there is no point of τ ( 1 ). however , in fig9 , even when the point of τ ( 1 ) does not exist , it is possible to evaluate the scalability . moreover , because this embodiment does not depend on the load division method , this embodiment can be applied to any type of architectures . in addition , because the effect of the load balance is taken into account , this embodiment can be applied to all of the load division methods such as data parallel or control parallel . incidentally , when seeing the graph depicted in fig9 , it is possible to judge the slope of the curve to some degree . however , when the following processing is carried out , it is possible to indicate the slope of the curve to the user . namely , returning to the explanation of fig7 , the scalability limit point judgment unit 22 of the scalability processor 12 carries out a scalability limit point identifying processing ( step s 9 ). this scalability limit point identifying processing will be explained by using fig1 . incidentally , the following processing is a processing for one parallel computer system , and when plural parallel computer systems should be treated , the processing depicted in fig1 is carried out plural times . first , the scalability limit point judgment unit 22 identifies the least number p of processors by using data stored in the scalability limit point judgment data storage 40 ( step s 21 ). then , the scalability limit point judgment unit 22 calculates slope δτ lt / δτ for the identified number p of processors , and stores the calculated value into the scalability limit point judgment data storage 40 ( the column of δτ lt / δτ ) ( step s 23 ). specifically , the calculation is carried out according to the following expression . incidentally , because the sign of the slope is used in the following processing , the sign of the slope is also stored into the scalability limit point judgment data storage 40 ( i . e . the column of the slope in fig8 ). then , the scalability limit point judgment unit 22 judges whether or not the slope is positive ( step s 25 ). when the slope is not positive , the processing shifts to step s 33 . when the slope is positive , the scalability limit point judgment unit 22 judges whether or not the slope “ positive ” is successively calculated the predetermined number of times ( step s 27 ). this processing is carried out in order not to identify the limit point of the scalability by the measurement errors and the calculation errors , and the predetermined number of times is determined according to occurrence frequency of the measurement errors and the calculation errors . when the slope “ positive ” is not calculated successively , the scalability limit point judgment unit 22 judges whether or not unprocessed data remains in the scalability limit point judgment data storage 40 ( step s 33 ). when the unprocessed data remains , the scalability limit point judgment unit 22 identifies the next greater number p of processors in the scalability limit point judgment data storage 40 ( step s 31 ), and the processing returns to the step s 23 . on the other hand , when unprocessed data does not remain , namely , data concerning all of the numbers p of processors has been processed , the scalability limit point judgment unit 22 outputs data representing the limit point cannot be identified to the output device 110 , and the processing returns to the original processing ( step s 35 ). that is , it is understood that it is impossible to identify a portion that the scalability does not exist . when the slope “ positive ” successively occurs the predetermined number of times , the scalability limit point judgment unit 22 identifies a scalability limit point by using a value of p or the like before the predetermined number of times ( step s 29 ). the identified result is stored , for example , in the scalability limit point judgment data storage 40 , and outputted to the output device 110 . the output device 110 plots the limit point in such a manner that it can be discriminated from other points , for example , on the scalability evaluation graph . for example , it is emphasized by a different color or is displayed with the blinks . the processing of the step s 29 uses the number p of processors before the predetermined number of times , simply . for example , “ 2 ” is set to the predetermined number of times , and at p = 14 , the slope changes to positive in fig8 , and at p = 16 , the processing shifts to the step s 29 . in this case , the scalability limit point is identified as p = 12 and τ ( p )= 539 . 20 , which were identified before twice . on the other hand , the number p of processors , at which the slope becomes 0 , may be calculated by the interpolation . in the example of fig8 , the following calculation is carried out because the slope is changed at p = 12 and p = 14 . such a simple method may be adopted or the point at which the slope becomes 0 may be actually identified by the interpolation . by carrying out such a processing , it becomes possible to analytically calculate the scalability limit point and present it for the user . incidentally , the processing returns to the original processing after the step s 29 . returning to the explanation of fig7 , when comparing the plural parallel computer systems 200 with respect to the scalability , the scalability comparison unit 23 of the scalability processor 12 carries out a scalability comparison processing by using data stored in the scalability limit point judgment data storage 40 ( step s 11 ). in such a case , for example , it is assumed that , in addition to the data as depicted in fig8 , data as depicted , for example in fig1 is also stored in the scalability limit point judgment data storage 40 . in the example of fig1 , the slope temporarily becomes positive at p = 3 because of the measurement errors and / or the calculation errors . however , because the slope “ positive ” does not successively occur , the scalability limit point is not identified at p = 3 . in addition , the slope becomes “ positive ” at p = 12 again . however , because it does not successively occur the predetermined times , the scalability limit point is not also identified at p = 12 . incidentally , when representing fig8 and 11 by the scalability evaluation graph , fig1 is obtained . thus , when the parallel computer system a ( fig8 ) is compared with the parallel computer system b ( fig1 ), a portion x in which τ ( p ) overlaps exists . because both of the slopes are negative in this portion x , this is a portion the scalability exists . in the scalability comparison processing , the limit processing times τ lt ( p ) at the same τ ( p ) within the portion the scalability exists is compared . in the example of fig8 and 11 , the limit processing time τ lt ( p ) of one parallel computer system is calculated by extrapolation on a basis of the other parallel computer system . for example , when the parallel computer system b is a reference , the extrapolation is carried out for the parallel computer system a . when the parallel computer system b is a reference , τ ( 1 )= 768 . 19 and τ lt ( 1 )= 10 . 691 are used as a reference point in the portion x . the point of the parallel computer system a near τ = 768 . 19 is represented by τ ( 6 )= 693 . 09 and τ lt ( 6 )= 264 . 59 , and δτ lt / δτ =− 0 . 25225 is used . then , τ lt = 246 (=− 0 . 25225 *( 768 . 19 − 693 . 09 )+ 264 . 59 ). namely , the scalability of the parallel computer system b is 23 times (= 246 / 10691 ) as good as the scalability of the parallel computer system a as a ratio of the limit processing time τ lt . thus , the short limit processing time is better . on the other hand , it is possible to use the parallel computer system a as a reference . in such a case , by using τ ( 6 )= 693 . 09 and τ lt ( 6 )= 264 . 59 as a reference , a point , which is represented by τ ( 1 )= 768 . 19 and τ lt ( 6 )= 10 . 691 and is near τ ( 6 )= 693 . 09 , is used . at that time , δτ lt / δτ =− 0 . 016356 . then , τ lt at τ = 693 . 09 is calculated as follows : therefore , at τ = 693 . 09 , the scalability of the parallel computer system b is 22 time (= 264 . 59 / 11 . 9 ) as good as the scalability of the parallel computer system a as a ratio of the limit processing time τ lt . although the embodiment of this invention was explained , this invention is not limited to this embodiment . for example , the functional block diagram of fig5 is a mere example , and does not always correspond to a program module configuration . in addition , processing units such as the scalability limit point judgment unit 22 and the scalability comparison unit 23 may not be provided . as for the processing flow , when the same result can be obtained , the order of the processing step may be exchanged and may be executed in parallel .