Patent Publication Number: US-6904325-B2

Title: Method for optimizing ECU parallel flash programming arrangement on a CAN-based vehicle serial bus in general assembly

Description:
FIELD OF THE INVENTION 
     The present invention generally relates to vehicle assembly systems and methods, and particularly to parallel flash programming of multiple ECUs on a CAN-based vehicle serial bus for use during a vehicle assembly process. 
     BACKGROUND OF THE INVENTION 
     Today&#39;s vehicle final assembly process&#39; uses, for example, a portable programming and testing tool  10  mounted on the vehicle steering wheel  12  as shown in  FIG. 1  to flash program vehicle calibration tables for vehicle electrical control units (ECUs). For example, the power train control module (PCM) is one of the ECU&#39;s flash-programmed at the assembly plant. Flash programming at assembly plants provides a flexible mechanism for incorporating changes in calibration tables. However, this programming process consumes limited and valuable production job space on the final assembly line. In the past few years, the software content of vehicle ECUs has increased, requiring more time (thus more workstation space on the assembly line) for flash programming. 
     An improved controller area network (CAN) bus is being introduced in various vehicle platforms. As a CAN-based (ISO 11898 and ISO 15765) serial protocol, the improved CAN bus divides one message into 8 byte frames and transmits one 8-byte frame at a time. Between subsequent frames designated to the same ECU, there has to be a wait time (called the inter-frame wait time). The inter-frame wait time is wasted time on the CAN bus. Parallel flash programming is a technique to utilize the inter-frame wait time on the CAN bus for flashing another ECU at the same time to achieve near 100% CAN bus utilization. Parallel flash programming is also termed the frame interleaving technique. Accordingly, given N ECUs, if the inter-frame wait time  16  is set to a multiple M (&lt;N) of the single frame transfer time, a total of M+1 ECUs can theoretically be parallel flash programmed. As shown in  FIG. 2 , when the inter-frame wait time  16  is set to twice the single frame transfer time  14 , the interleaving of three frames are achieved, thus three ECUs (A, B, and C) may be parallel flash programmed at the same time. 
     As a vehicle manufacturer moves to a common electrical architecture for vehicle control systems, more and more ECUs are shared across vehicle platforms and more and more software-enabled features are delivered via the assembly plant process. Thus, when multiple ECUs are connected to the same CAN bus, each ECU has different sets of calibration tables to be flash programmed at the assembly plant. As a result, many strategies exist to flash program multiple ECUs, and the number of possible strategies rises with the number of ECUs connected to the bus. As an example shown in  FIG. 3 , seven ECUs  18 A- 18 G are connected to the same CAN bus  20  in a vehicle. Thus, one strategy is, for example, to parallel flash program all seven ECUs at the same time. In contrast, another strategy is to parallel flash program three ECUs and then four ECUs. Many more strategies also exist. However, selecting the right strategy to reduce programming time and increase use of the bus  20  is a difficult problem. The present invention provides a solution to this problem. 
     SUMMARY OF THE INVENTION 
     In accordance with the present invention, a parallel flash programming system for use in motor vehicle assembly includes an input receptive of information relating to a predetermined number of processors connected to a system bus, processor flash programming attributes, and system bus attributes. An incremental flash programming times determination module is adapted, based on the information, to determine incremental flash programming times of a processor in relation to multiple interframe wait times respective of multiple parallel flash programming schema in accordance with the predetermined number of processors. A global flash programming time resolution module is adapted to determine, based on incremental flash programming times respective of multiple processors of the predetermined number, an assignment of the multiple processors to a number of parallel programming tracks yielding a global flash programming time in accordance with predetermined criteria. 
     Further areas of applicability of the present invention will become apparent from the detailed description provided hereinafter. It should be understood that the detailed description and specific examples, while indicating the preferred embodiment of the invention, are intended for purposes of illustration only and are not intended to limit the scope of the invention. 
    
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
       The present invention will become more fully understood from the detailed description and the accompanying drawings, wherein: 
         FIG. 1  is a perspective view of a portable programming and testing tool used for flash programming ECUs at a final assembly line in a motor vehicle assembly plant in accordance with the present invention; 
         FIG. 2  is a temporal graph illustrating simultaneous, parallel flash programming of multiple ECUs utilizing inter-frame wait time on a CAN bus in accordance with the present invention; 
         FIG. 3  is an entity relationship diagram illustrating simultaneous connection of multiple ECUs to a CAN serial bus in a motor vehicle in accordance with the present invention; 
         FIG. 4  is a functional block diagram depicting a parallel flash programming system in accordance with the present invention; 
         FIG. 5  is a flow diagram depicting a parallel flash programming method in accordance with the present invention; 
         FIG. 6  is a flow diagram depicting a heuristic method of selecting a number of parallel programming tracks that yields a minimum global flash programming time in accordance with the present invention; 
         FIG. 7  is a graph illustrating use of a Tmax(j) curve to find the optimal number of parallel tracks in accordance with the present invention; 
         FIG. 8  is a flow diagram depicting a heuristic method of assigning processors to the selected number of parallel programming tracks to achieve a reduced global flash programming time in accordance with the present invention; and 
         FIG. 9  is a temporal graph illustrating minimized total flash programming time for three parallel tracks. 
     
    
    
     DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS 
     The following description of the preferred embodiment(s) is merely exemplary in nature and is in no way intended to limit the invention, its application, or uses. 
     Referring to  FIG. 2 , the frame interleaving technique is a known process. However, the present invention incorporates a novel identification and analysis of the variables affecting performance of this process. Accordingly, the time to parallel flash program an ECU is dependent upon the message transfer time  22 , which is a function of ECU buffer size, single frame transfer time  14 , and interframe wait time  16 . It is also dependent on response time  24  and flash write time  26 . Further, the ECU flash programming time is dependent on the total number of messages  22 , which is a function of the number and sizes of calibration tables and/or vehicle software files to be programmed on the ECU. In turn, single frame transfer time is dependent on system bus attributes, and interframe wait time  14  is dependent on the number of ECUs being parallel flash programmed. Thus, parallel flash programming system  28  of  FIG. 4  in accordance with the present invention employs information relating to a total number of processors  30  connected to the system bus, system bus attributes  32 , and processor flash programming attributes  34 . 
     In a first embodiment, system  28  includes an interframe wait times determination module  36  adapted to determine maximum and minimum interframe wait times  38  based on the number of processors  30  and system bus attributes. Accordingly, incremental flash programming times determination module  40  receives the wait times  38  and processor flash programming attributes  34  corresponding to experimentally determined maximum and minimum flash programming times for each processor. Module  40  accordingly calculates multiple, incremental flash programming times  42  for each processor with reference to each potential interframe wait time as further explained below with reference to FIG.  5 . 
     In a second embodiment, module  40  ( FIG. 4 ) of system  28  receives information relating to number of processors  30 , system bus attributes  32 , and processor flash programming attributes  34 . The system bus attributes  32  include bus baudrate, bits per frame, and time to the start of flow control frame transmission. The processor flash programming attributes  34  include processor buffer size, number and size of tables, response time  24 , and flash write time  26 . Module  40  determines all of the potential interframe wait times based on the number of processors  30  and the system bus attributes  32 . Module  40  also determines multiple, incremental flash programming times  42  for each potential interframe wait time based on the processor flash programming attributes  34 . These processes are further explained below with reference to FIG.  5 . 
     In accordance with either the first embodiment or the second embodiment, global flash programming time minimization module  44  ( FIG. 4 ) receives processor flash programming times  42 . This information is preferably received in the form of an N×N matrix having processor rows, potential interframe wait time columns, and processor flash programming time cells. Module  44  also generates an assignment of processors  46  to a number of parallel flash programming tracks that yields a minimal global flash programming time; herein, tracks are considered equivalent to sessions or channels. Module  44  may operate in various ways according to two sub-embodiments. 
     According to the first sub-embodiment, module  44  operates by employing a sophisticated mixed integer program (MIP) solver such as XPRESS-MP or CPLEX to formulate an optimization of the global flash programming time in the presence of constraints. Thus, module  44  performs multiple combinatorial assignments of processors to various numbers of tracks utilizing constraints specifying at least one processor per track, and specifying no more tracks than the total number of processors  30 , which may be determined from the number of columns of the received matrix. Also, module  44  determines multiple global programming times based on the multiple combinatorial assignments and the incremental flash programming times. Further, module  44  selects an assignment of processors to a number of tracks that minimizes the global flash programming time. These procedures are further explained below with reference to FIG.  5 . 
     According to the second sub-embodiment, module  44  ( FIG. 4 ) operates by utilizing a heuristic technique. The heuristic technique includes determining multiple, average flash programming times of multiple interframe wait times based on the incremental flash programming times. It also includes recursively comparing average flash programming times of each interframe wait time to a flash programming time of greatest magnitude for the interframe wait time and recording the difference. It further includes selecting an interframe wait time at which the difference is minimized, and selecting a number of parallel programming tracks corresponding to the interframe wait time. The heuristic technique also includes assigning processors to tracks as further explained below with reference to FIG.  6 . 
     Turning now to  FIG. 5 , the present invention provides a method to determine the best strategy for parallel flash programming multiple ECUs on the same CAN bus so that the total flash programming time is minimized. Two embodiments provide the option of proceding experimentally or mathematically as at  48 . If proceeding experimentally, the invention includes determining maximum and minimum interframe wait times at step  50  for parallel programming all processors at once versus programming only one processor at a time. For example, given a total of N ECUs on the CAN bus to be flash programmed at the assembly plant, the invention includes determining minimum and maximum inter-frame wait times T IFW (0) and T IFW (1) according to: 
                 T   IFW     ⁡     (   0   )       =     min   ⁢           ⁢     T   IFW     ⁢           ⁢   and             (   1.1   )                   T   IFW     ⁡     (   1   )       =       (     N   -   1     )     *       Bits   frame       P   bus                 (   1.2   )             
 
MinT IFW  refers to the minimum inter-frame wait time. P bus  refers to the CAN bus baudrate. Bits frame  refers to the number of bits per frame transmitted over the CAN bus. 
         Bits   frame       P   bus         
 
refers to the single frame transfer time. For i th  ECU (i=1, . . . , N), the inter-frame wait time for each ECU is set to be (1.1) and (1.2).
 
     The invention also includes determining the flash programming time for each ECU either mathematically or by experiment. For example, determining the flash programming time by experiment at step  52  includes programming the i th  ECU to determine the minimum and maximum flash programming time T(i,0) and T(i,N−1). These parameters, minimum and maximum interframe wait times and minimum and maximum flash programming times are then received at step  54 . as flash programming attributes and system bus characteristics. However, if the method is proceeding mathematically, then the parameters received at step  54  are more detailed as described above with reference to FIG.  4 . Accordingly, the flash programming time T(i,0) and T(i,N−1) may be calculated mathematically for each ECU at each potential interframe wait time in steps  56  and  58  according to: 
               T   ⁡     (     i   ,   j     )       =       ∑     x   =   1     m     ⁢           ⁢         S     calset   ⁡     (   x   )           S   Buffer       *     (         (     1   +     Roundup   ⁡     (         S   Buffer     -   6     7     )         )     *     (         Bits   frame       P   Bus       +     T   IFWt       )       +     T   FW     +     2   *     T   resp       +     T   FR       )                 (   1.3   )             
 
S Buffer  refers to buffer size in bytes. S calset(x)  refers to size of each calibration table in bytes. m refers to the total number of calibration tables to be flash programmed for the ECU. P Bus  refers to CAN bus baudrate. Bits frame  refers to number of bits per frame. T IFWt  refers to inter-frame wait time. T FW  refers to time to write calibration data in RAM buffer to the flash memory device. T resp  refers to time to transfer the response frame. T FR  refers to time to the start of flow control frame transmission. Alternatively, the incremental flash programming times may be determined based on the experimental data by generating an N×N matrix: 
             [           T   ⁡     (     1   ,   0     )             T   ⁡     (     1   ,   1     )           …         T   ⁡     (     1   ,     N   -   1       )                 T   ⁡     (     2   ,   0     )             T   ⁡     (     2   ,   1     )           …         T   ⁡     (     2   ,     N   -   1       )               …       …       …       …             T   ⁡     (     N   ,   0     )             T   ⁡     (     N   ,   1     )           …         T   ⁡     (     N   ,     N   -   1       )             ]           (   1.4   )             
 
according to: 
               T   ⁡     (     i   ,   j     )       =       T   ⁡     (     i   ,     N   -   1       )       -       (         T   ⁡     (     i   ,     N   -   1       )       -     T   ⁡     (     i   ,   0     )               T   IFW     ⁡     (   1   )       -       T   IFW     ⁡     (   0   )           )     *     [       (     N   -   1     )     -   j     ]     *       Bits   frame       P   bus                   (   1.5   )             
 
The same matrix may be generated mathematically by equation (1.3), with the potential interframe wait times being determined according to: 
                   T   IFW     ⁡     (   j   )       =       j   *       Bits   frame       P   bus       ⁢           ⁢   j     =   1       ,   2   ,   …   ⁢           ,     N   -   1             (   1.6   )             
 
The row of matrix (1.4) is for i th  ECU with incremental inter-frame wait time set to be min, 1, 2, . . . , (N−1) frame transfer time. The column of matrix (1.4) is for all N ECUs with an identical inter-frame wait time. It should be readily understood that matrix (1.4) is a preferred data structure. It is envisioned that other data structures may be employed with the present invention to record incremental flash programming times for processors in association with potential interframe wait times.
 
     The method includes finding a global minimum flash programming time based on the incremental flash programming times at step  60 . Also, the method includes making a selection of an assignment of processors to a number of parallel programming tracks yielding the global minimum flash programming time at step  62 . Finally, the method may include parallel flash programming the processors in accordance with the selection at step  64 . 
     A first sub-embodiment accomplishes steps  60  and  62  by solving the following math programming problem to find the global minimum total flash programming time under the presence of constraints on the maximum and minimum number of parallel tracks to exploit. 
     Parameters: 
     
         
         
           
             N&gt;=0—Number of ECUs 
             Matrix T as found in (1.4) 
             MaxNumberOfParallelTracks&gt;=1—Maximum number of permissible parallel tracks to use 
             MinNumberOfParallelTracks&gt;=1—Minimum number of permissible parallel tracks to use
 
Variables:
 
             TotalProgrammingTime[i] for all i in 1 . . . N&gt;=0, &lt;=(max {j in 0 . . . N−1}  T[i,j])−Total Flash Programming Time associated with ECU i 
             X[i,j] for all i,j in 1 . . . N&gt;=0, &lt;=(max {k in 0 . . . N−1}  T[i,k])—The amount of time required to flash i th  ECU (function of w) 
             Y[i,j] for all i,j in 1 . . . N, binary—A variable that equals 1 if the i th  ECU assigned to j th  track. 0 otherwise. 
             W[i] for all i in 0 . . . N-1, binary—A variable that equals 1 if inter-frame spacing is equal to i frame-units. 0 otherwise. 
             lastTime&gt;=0, &lt;=(sum{i in 1 . . . N} (max {j in 0 . . . N−1}  T[i,j]))—Total flash programming time 
             V[j] for all j in 1 . . . N; binary—0-1 variable that indicates that parallel track j must have an ECU assigned to it
 
Mixed Integer Program (MIP) Combinatorial Optimization Formulation:
 
           
         
         Minimize lastTime (1.7) 
         Subject to:
       W[j]=0 for all j in MaxNumberOfParallelTracks . . . N−1 (1.7.1)   W[j]=0 for all j in 0 . . . MinNumberOfParallelTracks—2 such that minNumberOfParallelTracks&gt;1 (1.7.2)   sum{j in 1 . . . number_OF_ECU} Y[i,j]=1 for all i in 1 . . . N (1.7.3)   X[i,j]&lt;=(max {k in 0 . . . N−1}  programmingTime[i,k])*Y[i,j] for all i,j in 1 . . . N (1.7.4)   X[i,j]&gt;=T[i,j−1]*Y[i,j] for all i in 1 . . . N, j in 1 . . . N (1.7.5)   sum{i in 1 . . . N}x [i,j]&lt;=lastTime for all j in 1 . . . N (1.7.6)   TotalProgrammingTime [i]&lt;=lastTime for all i in 1 . . . N (1.7.7)   sum{i in 0 . . . N−1} w[i]=1; (1.7.8)   sum{j in 1 . . . N} X[i,j]=TotalProgrammingTime[i] for all i in 1 . . . N (1.7.9)   TotalProgrammingTime[i]=sum{j in 0 . . . N−1} T[i,j]*W[j] for all i in 1 . . . N (1.7.10)   Y[i,j]&lt;=1−W[k] for all i in 1 . . . N, j in 1 . . . N, k in 0 . . . N−1 such that j&gt;k+1 (1.7.11)   X[i,j]&lt;=(max {i in 0 . . . N−1}  T[i,l])*(1−W[k]) for all i in 1 . . . N, j in 1 . . . N, k in 0 . . . N−1 such that j&gt;k+1 (1.7.12)   sum{j in 1 . . . N: j&lt;=k+1} Y[i,j]&gt;=W[k] for all i in 1 . . . N, k in 0 . . . N−1 ( 1.7.13)      W[numSlot]&lt;=V[j] for all numSlot in 0 . . . N−1, j in 1 . . . N: j&lt;=numSlot+1 (1.7.14)   1−W[numSlot]&gt;=[j] for all numSlot in 0 . . . N−1, j in 1 . . . N: j&gt;numSlot+1 (1.7.15)   V[j]&lt;=sum{i in 1 . . . N} y[i,j] for all j in 1 . . . N (1.7.16)   V[j]&gt;=Y[i,j] for all j in 1 . . . N, i in 1 . . . N (1.7.17)   
     
       
    
     This problem is an example of a potentially difficult combinatorial optimization problem. The above formulation requires a sophisticated MIP solver like XPRESS-MP or CPLEX. However, when a solver such as these is not available, it remains possible to accomplish steps  60  and  62  using heuristic techniques to find the interframe wait time yielding the minimum global flash programming time, and to assign the corresponding processor flash programming times to an appropriate number of parallel flash programming tracks. These heuristic techniques are explored with reference to  FIGS. 6-9 . 
       FIG. 6  illustrates a heuristic procedure that quickly identifies a viable optimal number of parallel flash programming tracks to use. It also helps a user to choose another parallel track number and find the lower bound for the choice. Accordingly, the method includes determining an average flash programming time for each potential interframe wait time at step  66 . In a preferred embodiment, step  66  includes calculating the average value of the j th  column of matrix (1.4) according to: 
                   T   ave     ⁡     (   j   )       =         1     j   +   1       ⁢       ∑     i   =   1     N     ⁢           ⁢       T   ⁡     (     i   ,   j     )       ⁢           ⁢   j         =   0       ,   1   ,   2   ,   …   ⁢           ,     N   -   1             (   1.8   )               
The method also includes comparing the average flash programming time to the maximum flash programming time for each potential interframe wait time and recording the difference at step  70 . In a preferred embodiment, step  72  includes calculating a maximum value of the j th  column as 
                   T   max     ⁡     (   j   )       =         max     i   =     1   ⁢   …   ⁢           ⁢   N         ⁢       (       T   ⁡     (     i   ,   j     )       ,       T   ave     ⁡     (   j   )         )     ⁢           ⁢   j       =   0       ,   1   ,   2   ,   …   ⁢           ,     N   -   1             (   1.9   )               
and plotting the N by N matrix (1.4) and (1.9) with respect to its inter-frame wait time. The space above the upper curve (1.9) is the actual feasible region for an optimal solution.
 
       FIG. 7  illustrates the resulting plot of matrix (1.4) and (1.9) in an example for seven processors. The leftmost portion  70 A of the upper curve illustrates that the average value decreases as the interframe wait time increases. The rightmost portion  70 B of the upper curve illustrates that the maximum value increases as the interframe wait time increases. A global minimum value is identified at  72  such that the optimal parallel track number is four; the total flash programming time for all seven ECUs arranged on four parallel tracks is minimized compared to other parallel track numbers. Selecting this track number in steps  74  ( FIG. 6 ) and  76  is equivalent to selecting an interframe wait time at which the difference between the average and maximum values is minimized in step  74 , and designating a track pool of a number corresponding to the selected interframe wait time at step  76 . In a preferred embodiment, steps  74  and  76  include finding the minimum value of Tmax set min(T max (j)) at j min , where j min  is the number of parallel tracks which yield minimum total flash programming time for the given N ECUs. However, if the user prefers another parallel track number, the user can quickly find the lower bound for the total flash programming time at that number of tracks, because the total flash programming time cannot be smaller than T max  (j). 
       FIG. 8  illustrates an iterative process for effectively finding an effective processor assignment on the chosen track without using a powerful optimization solver. This heuristic technique finds, the grouping of ECUs to achieve the minimized total flash programming time for the desired number of tracks. The heuristic method eliminates the-explicit consideration of single ECU assignment to all possible tracks, and, thus, removes a huge number of solutions from the consideration set that normally must be searched by traditional MIP techniques. It is a recursive procedure that proceeds through each of the tracks and determines the ECU assignment that achieves the minimum total flash programming time. It utilizes a very simple and effective rule to pick the candidate ECUs for the current candidate track if multiple choices are available. 
     This heuristic technique uses the total number of tracks j identified as detailed above. The best potential flash programming time will be T max (j)based on equation (1.9). However, the discrete nature of flash programming time for each ECU ensures that the final minimized flash programming time will be longer than that lower bound. Achieving a best fit of processor flash programming times to tracks minimizes this time as effectively as possible. Accordingly, the method includes designating a time pool of unassigned flash programming times associated with the selected interframe wait time at step  78 . In a preferred embodiment, step  78  includes selecting the j th  column of matrix (1.4), {right arrow over (V)}=T(i,j), where i=1 ,2, . . . , N. This vector is for all N ECUs with (j−1) times single frame transfer time to accommodate the total of j parallel tracks. Step  78  further preferably includes sorting the vector in an ascending order from minimum value to maximum value {right arrow over (V)} sorted . The method also includes designating an empty track of the track pool as the current track at step  80 . Step  80  preferably includes starting at the first track as the current candidate track L. In  FIG. 9 , for example, L=1 is selected as a starting track number. The method further includes calculating a minimum global flash programming time for a current recursion at step  82  as a total of the flash programming times of the time pool divided by the number of remaining tracks of the track pool. 
     The flash programming time of greatest magnitude in the time pool is assigned to the current track at step  84 , which removes it from the pool. In a preferred embodiment, step  84  includes picking the maximum value of the sorted vector, Vmax =max({right arrow over (V)} sorted )and placing this ECU on the current candidate track L. In  FIG. 9 , for example, ECU A is the first Vmax picked for the current track L=1 during a first recursion. Then a best fit is found at step  86  ( FIG. 8 ) as the difference between the total time assigned to the current track and the minimum global flash programming time for the current recursion. In a preferred embodiment, step  86  includes calculating δ=T ave −V max  where 
               T   ave     =         ∑           ⁢     V   sorted         j   -   L   -   1       .             (   1.10   )             
 
Then, a flash programming time that most closely matches the best fit is selected at step  88 , and an evaluation is made as at  90  to determine if assignment of the selected time to the current track would be beneficial. In a preferred embodiment, steps  88  and  90  include picking a closest v(I) value to δ from the rest of the {right arrow over (V)} sorted  set and calculating: 
                 T   ave     ⁡     (   0   )       =         ∑           ⁢     V   sorted           (     j   +   1     )     -     (     L   +   1     )         ⁢           ⁢   and             (   1.11   )                   T   ave     ⁡     (   1   )       =         ∑           ⁢     V   sorted       -     V   ⁡     (   l   )             (     j   +   1     )     -     (     L   +   1     )                 (   1.12   )             
 
Equation (1.1 1) yields the average total flash programming time for the remaining tracks excluding the current-track if the current pick v(I) is not chosen. Similarly, equation (1.12) is the average total flash programming time for the remaining tracks if the current pick v(I) is chosen. Since (1.12) will always be smaller than the (1.11) value, any ECU assignment to the current track reduces future track total flash programming time. However, it is possible that the selected v(I) will be significantly larger than the best fit, and that an assignment of the selected v(I) to the current track will not be beneficial. Therefore, the preferred embodiment includes evaluating the benefit of assigning v(I) to the current track according to: 
                      T   ave     -       T   ave     ⁡     (   0   )              &gt;            T   ave     -       T   ave     ⁡     (   1   )                      (   1.13   )             
 
T ave  yields the minimum global flash programming time for the current recursion. Similarly, T ave (0) and T ave (1) thus yield the potential minimum global flash programming times for the next recursion, depending on whether v(I) is assigned to the current track. Thus, if (1.13) is true, then it is appropriate to assign v(I) to the current track. The rule enforced by (1.13) is an effective and efficient way to minimize the difference of flash programming time among subsequent tracks. As the example shown in  FIG. 9  demonstrates, this rule forces the difference between the total flash programming time of all three tracks to be minimized.
 
     If it proves beneficial to assign v(I) to the current track, then the selected flash programming time is assigned to current track at step  92 , which removes it from the time pool. Then, the method returns to step  86  and continues to assign best fitting times to the current track as long as it proves beneficial to do so. However, once it proves not beneficial to assign the selected time to the current track, then the current track is removed from the track pool at step  94 . If more than one track remains in the track pool as at  96 , then processing returns to step  80  and each empty track is assigned processor programming times in the same fashion as discussed above. However, it is only necessary to assign all remaining times in the time pool to the last remaining track at step  98 . Thus, in keeping with the preferred embodiment, steps  80 - 98  include recursively working with the remaining set of {right arrow over (V)} sorted  and incrementing L to the next track number until the track number-L reaches the total number of tracks j. 
     The description of the invention is merely exemplary in nature and, thus, variations that do not depart from the gist of the invention are intended to be within the scope of the invention. For example, the present invention may be employed lo optimize parallel flash programming in numerous contexts including but not limited to downloading calibration tables and downloading different types of vehicle software, such as software operable to adapt vehicle processors for operation of respective component systems. Also, the present invention is not limited to use during vehicle assembly. For example, the present invention may be employed to optimize parallel flash programming in numerous contexts including but not limited to vehicle pre-assembly, sub-assembly, vehicle upgrade, and vehicle repair procedures. Further, the invention may be used in wireless media for parallel flash programming multiple vehicle processors during operation as with vehicle navigation, operator assistance, and real-time entertainment systems. Moreover, the present invention is not limited to use with the portable programming and testing tool of  FIG. 1 , but can be implemented with any processor capable of parallel flash programming the vehicle, whether internal or external. Such variations are not to be regarded as a departure from the spirit and scope of the invention.