1 /*++ 2 3 Copyright (c) 2008 - 2010, Intel Corporation. All rights reserved.<BR> 4 This program and the accompanying materials 5 are licensed and made available under the terms and conditions of the BSD License 6 which accompanies this distribution. The full text of the license may be found at 7 http://opensource.org/licenses/bsd-license.php 8 9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 11 12 Module Name: 13 14 MultiThread.c 15 16 Abstract: 17 18 This module is used to add multi-thread build support to ProcessDsc utility 19 to improve the build performance. 20 21 --*/ 22 23 #include <windows.h> 24 #include <stdio.h> 25 #include <string.h> 26 #include <stdlib.h> 27 #include <direct.h> 28 #include "Common.h" 29 #include "MultiThread.h" 30 31 BUILD_ITEM * 32 AddBuildItem ( 33 BUILD_ITEM **BuildList, 34 INT8 *BaseName, 35 INT8 *Processor, 36 INT8 *Makefile 37 ) 38 /*++ 39 40 Routine Description: 41 42 Add a build item to a specified build list 43 44 Arguments: 45 46 BuildList - build list where the new build item will be added 47 BaseName - base name of the new module 48 Processor - processor type of the new module 49 Makefile - makefile name of the new module 50 51 Returns: 52 53 Pointer to the newly added build item 54 55 --*/ 56 { 57 BUILD_ITEM *NewBuildItem; 58 59 // 60 // Create a new build item 61 // 62 NewBuildItem = malloc (sizeof (BUILD_ITEM)); 63 if (NewBuildItem == NULL) { 64 return NULL; 65 } 66 memset (NewBuildItem, 0, sizeof (BUILD_ITEM)); 67 NewBuildItem->BaseName = _strdup (BaseName); 68 NewBuildItem->Processor = _strdup (Processor); 69 NewBuildItem->Makefile = _strdup (Makefile); 70 71 // 72 // Add the build item to the head of the build list 73 // 74 NewBuildItem->Next = *BuildList; 75 *BuildList = NewBuildItem; 76 77 return NewBuildItem; 78 } 79 80 SOURCE_FILE_ITEM * 81 AddSourceFile ( 82 BUILD_ITEM *BuildItem, 83 INT8 *FileName 84 ) 85 /*++ 86 87 Routine Description: 88 89 Add a source file for a build item 90 91 Arguments: 92 93 BuildItem - build item to add the source file 94 FileName - source file name to be added 95 96 Returns: 97 98 Pointer to the newly added source file item 99 100 --*/ 101 { 102 SOURCE_FILE_ITEM *NewSourceFile; 103 104 // 105 // Create a new source file item 106 // 107 NewSourceFile = malloc (sizeof (SOURCE_FILE_ITEM)); 108 if (NewSourceFile == NULL) { 109 return NULL; 110 } 111 memset (NewSourceFile, 0, sizeof (SOURCE_FILE_ITEM)); 112 NewSourceFile->FileName = _strdup (FileName); 113 114 // 115 // Add the source file item to the head of the source file list 116 // 117 NewSourceFile->Next = BuildItem->SourceFileList; 118 BuildItem->SourceFileList = NewSourceFile; 119 120 return NewSourceFile; 121 } 122 123 DEPENDENCY_ITEM * 124 AddDependency ( 125 BUILD_ITEM *BuildList, 126 BUILD_ITEM *BuildItem, 127 INT8 *BaseName, 128 INT8 AdjustIndex 129 ) 130 /*++ 131 132 Routine Description: 133 134 Add a build dependency for a build item in the specified build list 135 136 Arguments: 137 138 BuildList - build list where to search the dependency 139 BuildItem - build item to add the dependency 140 BaseName - dependency module base name 141 AdjustIndex - Adjust BuildItem->Index when non-zero 142 143 Returns: 144 145 Pointer to the newly added build dependency 146 147 --*/ 148 { 149 BUILD_ITEM *TempBuildItem; 150 DEPENDENCY_ITEM *NewDependency; 151 152 // 153 // Search the dependency in the build list 154 // 155 TempBuildItem = BuildList; 156 while (TempBuildItem != NULL) { 157 if ((_stricmp (TempBuildItem->BaseName, BaseName) == 0) && 158 (_stricmp (TempBuildItem->Processor, BuildItem->Processor) == 0) && 159 (TempBuildItem != BuildItem)) { 160 break; 161 } 162 TempBuildItem = TempBuildItem->Next; 163 } 164 if (TempBuildItem == NULL) { 165 return NULL; 166 } 167 168 // 169 // This index is used to isolate two modules with same base name and processor. 170 // (ProcessDsc allows duplicate base name libraries.) 171 // 172 if (AdjustIndex) { 173 BuildItem->Index = TempBuildItem->Index + 1; 174 } 175 176 // 177 // Create a new build dependency item 178 // 179 NewDependency = malloc (sizeof (DEPENDENCY_ITEM)); 180 if (NewDependency == NULL) { 181 return NULL; 182 } 183 memset (NewDependency, 0, sizeof (DEPENDENCY_ITEM)); 184 NewDependency->Dependency = TempBuildItem; 185 186 // 187 // Add the build dependency item to the head of the dependency list 188 // 189 NewDependency->Next = BuildItem->DependencyList; 190 BuildItem->DependencyList = NewDependency; 191 192 return NewDependency; 193 } 194 195 void 196 FreeBuildList ( 197 BUILD_ITEM *BuildList 198 ) 199 /*++ 200 201 Routine Description: 202 203 Free a build list 204 205 Arguments: 206 207 BuildList - build list to be freed 208 209 Returns: 210 211 --*/ 212 { 213 BUILD_ITEM *TempBuildItem; 214 BUILD_ITEM *FreeBuildItem; 215 SOURCE_FILE_ITEM *TempSourceFile; 216 SOURCE_FILE_ITEM *FreeSourceFile; 217 DEPENDENCY_ITEM *TempDependency; 218 DEPENDENCY_ITEM *FreeDependency; 219 220 TempBuildItem = BuildList; 221 while (TempBuildItem != NULL) { 222 free (TempBuildItem->BaseName); 223 free (TempBuildItem->Processor); 224 free (TempBuildItem->Makefile); 225 226 // 227 // Free source file list 228 // 229 TempSourceFile = TempBuildItem->SourceFileList; 230 while (TempSourceFile != NULL) { 231 FreeSourceFile = TempSourceFile; 232 TempSourceFile = TempSourceFile->Next; 233 free (FreeSourceFile); 234 } 235 236 // 237 // Free dependency list 238 // 239 TempDependency = TempBuildItem->DependencyList; 240 while (TempDependency != NULL) { 241 FreeDependency = TempDependency; 242 TempDependency = TempDependency->Next; 243 free (FreeDependency); 244 } 245 246 FreeBuildItem = TempBuildItem; 247 TempBuildItem = TempBuildItem->Next; 248 free (FreeBuildItem); 249 } 250 } 251 252 COMPONENTS_ITEM * 253 AddComponentsItem ( 254 COMPONENTS_ITEM **ComponentsList 255 ) 256 /*++ 257 258 Routine Description: 259 260 Add a new components item to a specified components list 261 262 Arguments: 263 264 ComponentsList - components list where the new components item will be added 265 266 Returns: 267 268 Pointer to the newly added components item 269 270 --*/ 271 { 272 COMPONENTS_ITEM *NewComponents; 273 COMPONENTS_ITEM *TempComponents; 274 275 // 276 // Create a new components item 277 // 278 NewComponents = malloc (sizeof (COMPONENTS_ITEM)); 279 if (NewComponents == NULL) { 280 return NULL; 281 } 282 memset (NewComponents, 0, sizeof (COMPONENTS_ITEM)); 283 284 // 285 // Add the components item to the tail of the components list 286 // 287 TempComponents = *ComponentsList; 288 if (TempComponents == NULL) { 289 *ComponentsList = NewComponents; 290 } else { 291 while (TempComponents->Next != NULL) { 292 TempComponents = TempComponents->Next; 293 } 294 TempComponents->Next = NewComponents; 295 } 296 297 return NewComponents; 298 } 299 300 void 301 FreeComponentsList ( 302 COMPONENTS_ITEM *ComponentsList 303 ) 304 /*++ 305 306 Routine Description: 307 308 Free a components list 309 310 Arguments: 311 312 ComponentsList - components list to be freed 313 314 Returns: 315 316 --*/ 317 { 318 COMPONENTS_ITEM *TempComponents; 319 COMPONENTS_ITEM *FreeComponents; 320 321 TempComponents = ComponentsList; 322 while (TempComponents != NULL) { 323 FreeBuildList (TempComponents->BuildList); 324 FreeComponents = TempComponents; 325 TempComponents = TempComponents->Next; 326 free (FreeComponents); 327 } 328 } 329 330 // 331 // Module globals for multi-thread build 332 // 333 static INT8 mError; // non-zero means error occurred 334 static INT8 mDone; // non-zero means no more build items available for build 335 static UINT32 mThreadNumber; // thread number 336 static INT8 *mBuildDir; // build directory 337 static INT8 mLogDir[MAX_PATH]; // build item log dir 338 static CRITICAL_SECTION mCriticalSection; // critical section object 339 static HANDLE mSemaphoreHandle; // semaphore for "ready for build" items in mWaitingList 340 static HANDLE mEventHandle; // event signaled when one build item is finished 341 static BUILD_ITEM *mPendingList; // build list for build items which are not ready for build 342 static BUILD_ITEM *mWaitingList; // build list for build items which are ready for build 343 static BUILD_ITEM *mBuildingList; // build list for build items which are buiding 344 static BUILD_ITEM *mDoneList; // build list for build items which already finish the build 345 346 // 347 // Restore the BuildList (not care about the sequence of the build items) 348 // 349 static void 350 RestoreBuildList ( 351 BUILD_ITEM **BuildList 352 ) 353 { 354 BUILD_ITEM *TempBuildItem; 355 356 if (mPendingList != NULL) { 357 // 358 // Add the mPendingList to the header of *BuildList 359 // 360 TempBuildItem = mPendingList; 361 while (TempBuildItem->Next != NULL) { 362 TempBuildItem = TempBuildItem->Next; 363 } 364 TempBuildItem->Next = *BuildList; 365 *BuildList = mPendingList; 366 } 367 368 if (mWaitingList != NULL) { 369 // 370 // Add the mWaitingList to the header of *BuildList 371 // 372 TempBuildItem = mWaitingList; 373 while (TempBuildItem->Next != NULL) { 374 TempBuildItem = TempBuildItem->Next; 375 } 376 TempBuildItem->Next = *BuildList; 377 *BuildList = mWaitingList; 378 } 379 380 if (mBuildingList != NULL) { 381 // 382 // Add the mBuildingList to the header of *BuildList 383 // 384 TempBuildItem = mBuildingList; 385 while (TempBuildItem->Next != NULL) { 386 TempBuildItem = TempBuildItem->Next; 387 } 388 TempBuildItem->Next = *BuildList; 389 *BuildList = mBuildingList; 390 } 391 392 if (mDoneList != NULL) { 393 // 394 // Add the mDoneList to the header of *BuildList 395 // 396 TempBuildItem = mDoneList; 397 while (TempBuildItem->Next != NULL) { 398 TempBuildItem = TempBuildItem->Next; 399 } 400 TempBuildItem->Next = *BuildList; 401 *BuildList = mDoneList; 402 } 403 } 404 405 // 406 // Return non-zero when no source file build conflict 407 // 408 static INT8 409 CheckSourceFile ( 410 SOURCE_FILE_ITEM *SourceFileList 411 ) 412 { 413 BUILD_ITEM *TempBuildItem; 414 SOURCE_FILE_ITEM *TempSourceFile; 415 416 while (SourceFileList != NULL) { 417 TempBuildItem = mBuildingList; 418 while (TempBuildItem != NULL) { 419 TempSourceFile = TempBuildItem->SourceFileList; 420 while (TempSourceFile != NULL) { 421 if (_stricmp (SourceFileList->FileName, TempSourceFile->FileName) == 0) { 422 return 0; 423 } 424 TempSourceFile = TempSourceFile->Next; 425 } 426 TempBuildItem = TempBuildItem->Next; 427 } 428 SourceFileList = SourceFileList->Next; 429 } 430 431 return 1; 432 } 433 434 // 435 // Return non-zero when all the dependency build items has been built 436 // 437 static INT8 438 CheckDependency ( 439 DEPENDENCY_ITEM *DependencyList 440 ) 441 { 442 while (DependencyList != NULL) { 443 if (!(DependencyList->Dependency->CompleteFlag)) { 444 return 0; 445 } 446 DependencyList = DependencyList->Next; 447 } 448 449 return 1; 450 } 451 452 // 453 // Run the build task. The system() function call will cause stdout conflict 454 // in multi-thread envroment, so implement this through CreateProcess(). 455 // 456 static INT8 457 RunBuildTask ( 458 INT8 *WorkingDir, 459 INT8 *LogFile, 460 INT8 *BuildCmd 461 ) 462 { 463 HANDLE FileHandle; 464 SECURITY_ATTRIBUTES SecAttr; 465 PROCESS_INFORMATION ProcInfo; 466 STARTUPINFO StartInfo; 467 BOOL FuncRetn; 468 DWORD ExitCode; 469 470 // 471 // Init SecAttr 472 // 473 SecAttr.nLength = sizeof (SECURITY_ATTRIBUTES); 474 SecAttr.bInheritHandle = TRUE; 475 SecAttr.lpSecurityDescriptor = NULL; 476 477 // 478 // Create the log file 479 // 480 FileHandle = CreateFile ( 481 LogFile, // file to create 482 GENERIC_WRITE, // open for writing 483 0, // do not share 484 &SecAttr, // can be inherited by child processes 485 CREATE_ALWAYS, // overwrite existing 486 FILE_ATTRIBUTE_NORMAL, // normal file 487 NULL // no attr. template 488 ); 489 490 if (FileHandle == INVALID_HANDLE_VALUE) { 491 EnterCriticalSection (&mCriticalSection); 492 Error (NULL, 0, 0, NULL, "could not open file %s", LogFile); 493 LeaveCriticalSection (&mCriticalSection); 494 return 1; 495 } 496 497 // 498 // Init ProcInfo and StartInfo 499 // 500 ZeroMemory (&ProcInfo, sizeof (PROCESS_INFORMATION)); 501 ZeroMemory (&StartInfo, sizeof (STARTUPINFO)); 502 StartInfo.cb = sizeof (STARTUPINFO); 503 StartInfo.hStdError = FileHandle; 504 StartInfo.hStdOutput = FileHandle; 505 StartInfo.hStdInput = GetStdHandle (STD_INPUT_HANDLE); 506 StartInfo.dwFlags = STARTF_USESTDHANDLES; 507 508 // 509 // Create the child process 510 // 511 FuncRetn = CreateProcess ( 512 NULL, // no application name 513 BuildCmd, // command line 514 NULL, // process security attributes 515 NULL, // primary thread security attributes 516 TRUE, // handles are inherited 517 0, // creation flags 518 NULL, // use parent's environment 519 WorkingDir, // set current directory 520 &StartInfo, // STARTUPINFO pointer 521 &ProcInfo // receives PROCESS_INFORMATION 522 ); 523 524 if (FuncRetn == FALSE) { 525 EnterCriticalSection (&mCriticalSection); 526 Error (NULL, 0, 0, NULL, "could not create child process"); 527 LeaveCriticalSection (&mCriticalSection); 528 CloseHandle (FileHandle); 529 return 1; 530 } 531 532 // 533 // Wait until child process exits 534 // 535 WaitForSingleObject (ProcInfo.hProcess, INFINITE); 536 GetExitCodeProcess (ProcInfo.hProcess, &ExitCode); 537 CloseHandle (ProcInfo.hProcess); 538 CloseHandle (ProcInfo.hThread); 539 CloseHandle (FileHandle); 540 541 if (ExitCode != 0) { 542 return 1; 543 } else { 544 return 0; 545 } 546 } 547 548 // 549 // Thread function 550 // 551 static DWORD WINAPI 552 ThreadProc ( 553 LPVOID lpParam 554 ) 555 { 556 UINT32 ThreadId; 557 BUILD_ITEM *PreviousBuildItem; 558 BUILD_ITEM *CurrentBuildItem; 559 BUILD_ITEM *NextBuildItem; 560 INT8 WorkingDir[MAX_PATH]; 561 INT8 LogFile[MAX_PATH]; 562 INT8 BuildCmd[MAX_PATH]; 563 564 ThreadId = (UINT32)lpParam; 565 // 566 // Loop until error occurred or no more build items available for build 567 // 568 for (;;) { 569 WaitForSingleObject (mSemaphoreHandle, INFINITE); 570 if (mError || mDone) { 571 return 0; 572 } 573 574 // 575 // When code runs here, there must have one build item available for this 576 // thread. Loop until error occurred or get one build item for build. 577 // 578 for (;;) { 579 EnterCriticalSection (&mCriticalSection); 580 PreviousBuildItem = NULL; 581 CurrentBuildItem = mWaitingList; 582 while (CurrentBuildItem != NULL) { 583 NextBuildItem = CurrentBuildItem->Next; 584 // 585 // CheckSourceFile() is to avoid concurrently build the same source file 586 // which may cause the muti-thread build failure 587 // 588 if (CheckSourceFile (CurrentBuildItem->SourceFileList)) { 589 // 590 // Move the current build item from mWaitingList 591 // 592 if (PreviousBuildItem != NULL) { 593 PreviousBuildItem->Next = NextBuildItem; 594 } else { 595 mWaitingList = NextBuildItem; 596 } 597 // 598 // Add the current build item to the head of mBuildingList 599 // 600 CurrentBuildItem->Next = mBuildingList; 601 mBuildingList = CurrentBuildItem; 602 // 603 // If no more build items is pending or waiting for build, 604 // wake up every child thread for exit. 605 // 606 if ((mPendingList == NULL) && (mWaitingList == NULL)) { 607 mDone = 1; 608 // 609 // Make sure to wake up every child thread for exit 610 // 611 ReleaseSemaphore (mSemaphoreHandle, mThreadNumber, NULL); 612 } 613 break; 614 } 615 PreviousBuildItem = CurrentBuildItem; 616 CurrentBuildItem = NextBuildItem; 617 } 618 if (CurrentBuildItem != NULL) { 619 // 620 // Display build item info 621 // 622 printf ("\t[Thread_%d] nmake -nologo -f %s all\n", ThreadId, CurrentBuildItem->Makefile); 623 // 624 // Prepare build task 625 // 626 sprintf (WorkingDir, "%s\\%s", mBuildDir, CurrentBuildItem->Processor); 627 sprintf (LogFile, "%s\\%s_%s_%d.txt", mLogDir, CurrentBuildItem->BaseName, 628 CurrentBuildItem->Processor, CurrentBuildItem->Index); 629 sprintf (BuildCmd, "nmake -nologo -f %s all", CurrentBuildItem->Makefile); 630 LeaveCriticalSection (&mCriticalSection); 631 break; 632 } else { 633 LeaveCriticalSection (&mCriticalSection); 634 // 635 // All the build items in mWaitingList have source file conflict with 636 // mBuildingList. This rarely hapeens. Need wait for the build items in 637 // mBuildingList to be finished by other child threads. 638 // 639 Sleep (1000); 640 if (mError) { 641 return 0; 642 } 643 } 644 } 645 646 // 647 // Start to build the CurrentBuildItem 648 // 649 if (RunBuildTask (WorkingDir, LogFile, BuildCmd)) { 650 // 651 // Build failure 652 // 653 mError = 1; 654 // 655 // Make sure to wake up every child thread for exit 656 // 657 ReleaseSemaphore (mSemaphoreHandle, mThreadNumber, NULL); 658 SetEvent(mEventHandle); 659 660 return mError; 661 } else { 662 // 663 // Build success 664 // 665 CurrentBuildItem->CompleteFlag = 1; 666 667 EnterCriticalSection (&mCriticalSection); 668 // 669 // Move this build item from mBuildingList 670 // 671 if (mBuildingList == CurrentBuildItem) { 672 mBuildingList = mBuildingList->Next; 673 } else { 674 NextBuildItem = mBuildingList; 675 while (NextBuildItem->Next != CurrentBuildItem) { 676 NextBuildItem = NextBuildItem->Next; 677 } 678 NextBuildItem->Next = CurrentBuildItem->Next; 679 } 680 // 681 // Add this build item to mDoneList 682 // 683 CurrentBuildItem->Next = mDoneList; 684 mDoneList = CurrentBuildItem; 685 LeaveCriticalSection (&mCriticalSection); 686 687 SetEvent(mEventHandle); 688 } 689 } 690 } 691 692 INT8 693 StartMultiThreadBuild ( 694 BUILD_ITEM **BuildList, 695 UINT32 ThreadNumber, 696 INT8 *BuildDir 697 ) 698 /*++ 699 700 Routine Description: 701 702 Start multi-thread build for a specified build list 703 704 Arguments: 705 706 BuildList - build list for multi-thread build 707 ThreadNumber - thread number for multi-thread build 708 BuildDir - build dir 709 710 Returns: 711 712 0 - Successfully finished the multi-thread build 713 other value - Build failure 714 715 --*/ 716 { 717 UINT32 Index; 718 UINT32 Count; 719 BUILD_ITEM *PreviousBuildItem; 720 BUILD_ITEM *CurrentBuildItem; 721 BUILD_ITEM *NextBuildItem; 722 HANDLE *ThreadHandle; 723 INT8 Cmd[MAX_PATH]; 724 725 mError = 0; 726 mDone = 0; 727 mThreadNumber = ThreadNumber; 728 mBuildDir = BuildDir; 729 mPendingList = *BuildList; 730 *BuildList = NULL; 731 mWaitingList = NULL; 732 mBuildingList = NULL; 733 mDoneList = NULL; 734 735 // 736 // Do nothing when mPendingList is empty 737 // 738 if (mPendingList == NULL) { 739 return 0; 740 } 741 742 // 743 // Get build item count of mPendingList 744 // 745 Count = 0; 746 CurrentBuildItem = mPendingList; 747 while (CurrentBuildItem != NULL) { 748 Count++; 749 CurrentBuildItem = CurrentBuildItem->Next; 750 } 751 752 // 753 // The semaphore is also used to wake up child threads for exit, 754 // so need to make sure "maximum count" >= "thread number". 755 // 756 if (Count < ThreadNumber) { 757 Count = ThreadNumber; 758 } 759 760 // 761 // Init mSemaphoreHandle 762 // 763 mSemaphoreHandle = CreateSemaphore ( 764 NULL, // default security attributes 765 0, // initial count 766 Count, // maximum count 767 NULL // unnamed semaphore 768 ); 769 if (mSemaphoreHandle == NULL) { 770 Error (NULL, 0, 0, NULL, "failed to create semaphore"); 771 RestoreBuildList (BuildList); 772 return 1; 773 } 774 775 // 776 // Init mEventHandle 777 // 778 mEventHandle = CreateEvent( 779 NULL, // default security attributes 780 FALSE, // auto-reset event 781 TRUE, // initial state is signaled 782 NULL // object not named 783 ); 784 if (mEventHandle == NULL) { 785 Error (NULL, 0, 0, NULL, "failed to create event"); 786 CloseHandle (mSemaphoreHandle); 787 RestoreBuildList (BuildList); 788 return 1; 789 } 790 791 // 792 // Init mCriticalSection 793 // 794 InitializeCriticalSection (&mCriticalSection); 795 796 // 797 // Create build item log dir 798 // 799 sprintf (mLogDir, "%s\\Log", mBuildDir); 800 _mkdir (mLogDir); 801 802 // 803 // Create child threads for muti-thread build 804 // 805 ThreadHandle = malloc (ThreadNumber * sizeof (HANDLE)); 806 if (ThreadHandle == NULL) { 807 Error (NULL, 0, 0, NULL, "failed to allocate memory"); 808 CloseHandle (mSemaphoreHandle); 809 CloseHandle (mEventHandle); 810 RestoreBuildList (BuildList); 811 return 1; 812 } 813 for (Index = 0; Index < ThreadNumber; Index++) { 814 ThreadHandle[Index] = CreateThread ( 815 NULL, // default security attributes 816 0, // use default stack size 817 ThreadProc, // thread function 818 (LPVOID)Index, // argument to thread function: use Index as thread id 819 0, // use default creation flags 820 NULL // thread identifier not needed 821 ); 822 if (ThreadHandle[Index] == NULL) { 823 Error (NULL, 0, 0, NULL, "failed to create Thread_%d", Index); 824 mError = 1; 825 ThreadNumber = Index; 826 // 827 // Make sure to wake up every child thread for exit 828 // 829 ReleaseSemaphore (mSemaphoreHandle, ThreadNumber, NULL); 830 break; 831 } 832 } 833 834 // 835 // Loop until error occurred or no more build items pending for build 836 // 837 for (;;) { 838 WaitForSingleObject (mEventHandle, INFINITE); 839 if (mError) { 840 break; 841 } 842 Count = 0; 843 844 EnterCriticalSection (&mCriticalSection); 845 PreviousBuildItem = NULL; 846 CurrentBuildItem = mPendingList; 847 while (CurrentBuildItem != NULL) { 848 NextBuildItem = CurrentBuildItem->Next; 849 if (CheckDependency (CurrentBuildItem->DependencyList)) { 850 // 851 // Move the current build item from mPendingList 852 // 853 if (PreviousBuildItem != NULL) { 854 PreviousBuildItem->Next = NextBuildItem; 855 } else { 856 mPendingList = NextBuildItem; 857 } 858 // 859 // Add the current build item to the head of mWaitingList 860 // 861 CurrentBuildItem->Next = mWaitingList; 862 mWaitingList = CurrentBuildItem; 863 Count++; 864 } else { 865 PreviousBuildItem = CurrentBuildItem; 866 } 867 CurrentBuildItem = NextBuildItem; 868 } 869 LeaveCriticalSection (&mCriticalSection); 870 871 ReleaseSemaphore (mSemaphoreHandle, Count, NULL); 872 if (mPendingList == NULL) { 873 break; 874 } 875 } 876 877 // 878 // Wait until all threads have terminated 879 // 880 WaitForMultipleObjects (ThreadNumber, ThreadHandle, TRUE, INFINITE); 881 882 if (mError && (mBuildingList != NULL)) { 883 // 884 // Dump build failure log of the first build item which doesn't finish the build 885 // 886 printf ("\tnmake -nologo -f %s all\n", mBuildingList->Makefile); 887 sprintf (Cmd, "type %s\\%s_%s_%d.txt 2>NUL", mLogDir, mBuildingList->BaseName, 888 mBuildingList->Processor, mBuildingList->Index); 889 _flushall (); 890 if (system (Cmd)) { 891 Error (NULL, 0, 0, NULL, "failed to run \"%s\"", Cmd); 892 } 893 } 894 895 DeleteCriticalSection (&mCriticalSection); 896 for (Index = 0; Index < ThreadNumber; Index++) { 897 CloseHandle (ThreadHandle[Index]); 898 } 899 free (ThreadHandle); 900 CloseHandle (mSemaphoreHandle); 901 CloseHandle (mEventHandle); 902 RestoreBuildList (BuildList); 903 904 return mError; 905 } 906
