Add explicit values to .clang-format

[sconvent]

Summary

Results differed on different systems without explicitly setting the added arguments

[jlpeyton]

runtime/.clang-format

6 ↗

(On Diff #118748)

This disables clang-format altogether when using -style=file? Why would we want this and doesn't it make other changes to this file useless? I believe we should just leave this file alone and clang-format the OMPT changes based on what the current configuration is.

[protze.joachim]

runtime/.clang-format

6 ↗

(On Diff #118748)

I understand the comments below as the expected values for

clang-format -dump-config -style=file

What we added is the diff of our output with the commented output. If the value is supposed to be false (as it is by default on my system/version) then this should also be changed below; and the value should still be explicitly listed as on some system the default seems to be true.

[protze.joachim]

For current HEAD of master I get a different result for any combination of the added values (unless I add the DisableFormat=true).
The smallest diff I get if I only add

MaxEmptyLinesToKeep: 2

[Hahnfeld]

So maybe the reason for that is using different versions of clang-format? @jlpeyton can you share which version you have been using to initially format the source code?

[AndreyChurbanov]

In D38837#896170, @Hahnfeld wrote:

So maybe the reason for that is using different versions of clang-format? @jlpeyton can you share which version you have been using to initially format the source code?

Right. We found that each (we haven't tried all versions of cause:) version of the clang-format produces different formatting, so we decided to stick with the version 3.8.1:
$ clang-format --version
clang-format version 3.8.1 (http://llvm.org/git/clang.git 9fd77bd68130d9b2fbc56a3138b6f981d560480a) (http://llvm.org/git/llvm.git 8b47c17a53d683f313eaaa93c4a53de26d8fcba5)

[Hahnfeld]

In D38837#896173, @AndreyChurbanov wrote:

Right. We found that each (we haven't tried all versions of cause:) version of the clang-format produces different formatting, so we decided to stick with the version 3.8.1:
$ clang-format --version
clang-format version 3.8.1 (http://llvm.org/git/clang.git 9fd77bd68130d9b2fbc56a3138b6f981d560480a) (http://llvm.org/git/llvm.git 8b47c17a53d683f313eaaa93c4a53de26d8fcba5)

So maybe some if this is needed to get it also to work with newer versions because they added options?

[jlpeyton]

That is peculiar that the DisableFormat attribute is true for our defaults in comments. I don't know why that is.

Anyways, I thought one could use git clang-format to only format the OMPT changes, or any current change. You do not have to format the entire file or maybe I have this wrong?

What I would try (if using git) is

1. Remove these changes to .clang-format
2. Take the large OMPT patch, create a separate branch based on current master
3. Apply the patch, and commit only the src/* files there. It looks like the test files shouldn't be run through clang-format because they contain large // CHECK: lines which should not be broken up. You can pick and choose of course.
4. Run:

$ git clang-format HEAD~1
This should reformat only the changes different between HEAD~1..HEAD (the large OMPT patch) and leave the reformatting changes in unstaged files so they are easy to get rid of if something goes wrong.

5. Commit the reformatting changes
6. Mash those new formatting changes in with the current OMPT patch
7. Submit it again to Phabricator :-D

The OMPT patch currently has lines that go over 80 characters (e.g., kmp_tasking.cpp) suggesting that the current OMPT patch has not been run through any real clang-format filter.

[Hahnfeld]

This might work for one patch but still doesn't solve the future problem, i.e. we don't want to be bound to 3.8.1 forever.

(I think Joachim came across this because he indeed had to format all sources: The changes were based on a commit before the code got reformatted. So if I remember correctly, he just formatted everything again so that the number of merge conflicts was reduced)

[jlpeyton]

Ah ok, I see now. When we first created .clang-format some specific attributes were changed from the defaults and not properly added. So we just need to remove the DisableFormat line, change the DisableFormat line in the comments to false (as Joachim noted), and the rest can stay. The OMPT patch still needs to be run through clang-format in some manner since the DisableFormat line probably prevented any real formatting to occur. After those changes this one looks good to me.

[protze.joachim]

I tried to update the attached diff, but accidently created a new differential: https://reviews.llvm.org/D38920
I built a clang-format using the source suggested by AndreyChurbanov. I still get a diff for the source of master.

[jlpeyton]

Ok, I've done some more research on this and here is what I've found and suggest as the solution:

1. It appears we didn't clang-format our codebase to completion or somehow these changes in https://reviews.llvm.org/D38920 slipped through the cracks. I don't know. Whatever the case, it is a good idea to commit these remaining format changes.
2. The current non-commented part of .clang-format is fine and does not need changes to it. Not even the MaxEmptyLinesToKeep change. The changes that occur when MaxEmptyLinesToKeep=1 is tidying up around the LLVM license inclusion parts in the comment headers in each file. Those changes are fine and would be consistent with our internal code base. That being said, the commented parts are confusing and should be removed as they are not consistent with the defaults for clang-format.
3. Different versions of clang-format can produce different results when you clang-format an entire file and there is no great solution. I've tried 3.7.1, 3.8.1, 3.9.1, 4.0 and all have given slightly different formatting for different parts of the code. If you try to include a new Attribute: Value pair in the .clang-format file and use an old clang-format executable, then the .clang-format file is ignored and the "fallback-style" is used (defaults to LLVM). For example, if you use an attribute added in v3.9, then you can only use v3.9+. Also, from what I've seen, the defaults do not change from 3.7.1 to 4.0.

A compromise to 3) is to use git clang-format which I've described above which only formats the changes in your commit and does not format the entire file. This way formatting is restricted to your changes and will not affect unrelated code. If all users tried to do the clang-format *.cpp *.h lines for every commit, and they are using differing clang-format versions, we would get oscillating formatting changes to unrelated parts of the code.

So the next steps I would suggest are this:

1. Remove all changes to non-commented part of .clang-format, Remove all comments in .clang-format.
2. Run clang-format 3.8.1 on the current codebase to incorporate the missing formatting changes in https://reviews.llvm.org/D38920 and also new changes removing double newlines.
3. Do something like I've described above on the OMPT change. It still needs to be run through clang-format and upload that to Phabricator.

Joachim, if you are ok with this I can do 1) and 2) and commit. Is this ok?

[protze.joachim]

In D38837#899143, @jlpeyton wrote:

Ok, I've done some more research on this and here is what I've found and suggest as the solution:

1. It appears we didn't clang-format our codebase to completion or somehow these changes in https://reviews.llvm.org/D38920 slipped through the cracks. I don't know. Whatever the case, it is a good idea to commit these remaining format changes.

I updated the attached diff in https://reviews.llvm.org/D38920 with the old format file. Is runtime/src/*.cpp runtime/src/*.h sufficient, or should other files be formated too?

2. The current non-commented part of .clang-format is fine and does not need changes to it. Not even the MaxEmptyLinesToKeep change. The changes that occur when MaxEmptyLinesToKeep=1 is tidying up around the LLVM license inclusion parts in the comment headers in each file. Those changes are fine and would be consistent with our internal code base. That being said, the commented parts are confusing and should be removed as they are not consistent with the defaults for clang-format.

I removed them in https://reviews.llvm.org/D38920. Simon can update this differential at the end of this week.

3. Different versions of clang-format can produce different results when you clang-format an entire file and there is no great solution. I've tried 3.7.1, 3.8.1, 3.9.1, 4.0 and all have given slightly different formatting for different parts of the code. If you try to include a new Attribute: Value pair in the .clang-format file and use an old clang-format executable, then the .clang-format file is ignored and the "fallback-style" is used (defaults to LLVM). For example, if you use an attribute added in v3.9, then you can only use v3.9+. Also, from what I've seen, the defaults do not change from 3.7.1 to 4.0.

A compromise to 3) is to use git clang-format which I've described above which only formats the changes in your commit and does not format the entire file. This way formatting is restricted to your changes and will not affect unrelated code. If all users tried to do the clang-format *.cpp *.h lines for every commit, and they are using differing clang-format versions, we would get oscillating formatting changes to unrelated parts of the code.

The main question remaining is, to what files should we apply clang-format. You already pointed out that we should not format tests.

So the next steps I would suggest are this:

1. Remove all changes to non-commented part of .clang-format, Remove all comments in .clang-format.
2. Run clang-format 3.8.1 on the current codebase to incorporate the missing formatting changes in https://reviews.llvm.org/D38920 and also new changes removing double newlines.
3. Do something like I've described above on the OMPT change. It still needs to be run through clang-format and upload that to Phabricator.

For the diff, that I uploaded on the weekend, I already applied clang-format - with the same values as in https://reviews.llvm.org/D38920.

These are the changes for using the old clang-format file:
https://reviews.llvm.org/D38185?vs=119034&id=119252&whitespace=ignore-most#toc

Joachim, if you are ok with this I can do 1) and 2) and commit. Is this ok?

Ok!

[jlpeyton]

The main question remaining is, to what files should we apply clang-format. You already pointed out that we should not format tests.

We also need to include kmp_itt.inl. So *.cpp *.h *.inl should do the trick.

openmp/trunk/runtime/.clang-format

 ---
 BasedOnStyle:  LLVM
 AlignTrailingComments: false
 SortIncludes:    false
----
-# Language: Cpp
-# AccessModifierOffset: -2
-# AlignAfterOpenBracket: Align
-# AlignConsecutiveAssignments: false
-# AlignConsecutiveDeclarations: false
-# AlignEscapedNewlinesLeft: false
-# AlignOperands: false
-# AlignTrailingComments: false
-# AllowAllParametersOfDeclarationOnNextLine: true
-# AllowShortBlocksOnASingleLine: false
-# AllowShortCaseLabelsOnASingleLine: false
-# AllowShortFunctionsOnASingleLine: All
-# AllowShortIfStatementsOnASingleLine: false
-# AllowShortLoopsOnASingleLine: false
-# AlwaysBreakAfterDefinitionReturnType: None
-# AlwaysBreakAfterReturnType: None
-# AlwaysBreakBeforeMultilineStrings: false
-# AlwaysBreakTemplateDeclarations: false
-# BinPackArguments: true
-# BinPackParameters: true
-# BraceWrapping:   
-#   AfterClass:      false
-#   AfterControlStatement: false
-#   AfterEnum:       false
-#   AfterFunction:   false
-#   AfterNamespace:  false
-#   AfterObjCDeclaration: false
-#   AfterStruct:     false
-#   AfterUnion:      false
-#   BeforeCatch:     false
-#   BeforeElse:      false
-#   IndentBraces:    false
-# # BreakBeforeBinaryOperators: None
-# BreakBeforeBraces: Attach
-# BreakBeforeTernaryOperators: true
-# BreakConstructorInitializersBeforeComma: false
-# ColumnLimit:     80
-# CommentPragmas:  '^ IWYU pragma:'
-# ConstructorInitializerAllOnOneLineOrOnePerLine: false
-# ConstructorInitializerIndentWidth: 4
-# ContinuationIndentWidth: 4
-# Cpp11BracedListStyle: true
-# DerivePointerAlignment: false
-# DisableFormat:   true
-# ExperimentalAutoDetectBinPacking: false
-# ForEachMacros:   [ foreach, Q_FOREACH, BOOST_FOREACH ]
-# IncludeCategories: 
-#   - Regex:           '^"(llvm|llvm-c|clang|clang-c)/'
-#     Priority:        2
-#   - Regex:           '^(<|"(gtest|isl|json)/)'
-#     Priority:        3
-#   - Regex:           '.*'
-#     Priority:        1
-# IndentCaseLabels: false
-# IndentWidth:     2
-# IndentWrappedFunctionNames: false
-# KeepEmptyLinesAtTheStartOfBlocks: false
-# MacroBlockBegin: ''
-# MacroBlockEnd:   ''
-# MaxEmptyLinesToKeep: 2
-# NamespaceIndentation: None
-# ObjCBlockIndentWidth: 2
-# ObjCSpaceAfterProperty: false
-# ObjCSpaceBeforeProtocolList: true
-# PenaltyBreakBeforeFirstCallParameter: 19
-# PenaltyBreakComment: 300
-# PenaltyBreakFirstLessLess: 120
-# PenaltyBreakString: 1000
-# PenaltyExcessCharacter: 1000000
-# PenaltyReturnTypeOnItsOwnLine: 60
-# PointerAlignment: Right
-# ReflowComments:  true
-# SpaceAfterCStyleCast: false
-# SpaceBeforeAssignmentOperators: true
-# SpaceBeforeParens: ControlStatements
-# SpaceInEmptyParentheses: false
-# SpacesBeforeTrailingComments: 1
-# SpacesInAngles:  false
-# SpacesInContainerLiterals: true
-# SpacesInCStyleCastParentheses: false
-# SpacesInParentheses: false
-# SpacesInSquareBrackets: false
-# Standard:        Cpp11
-# TabWidth:        8
-# UseTab:          Never
 ...

openmp/trunk/runtime/src/extractExternal.cpp

 /*
  * extractExternal.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <fstream>
 #include <iostream>
 #include <map>
 #include <set>
 #include <stdlib.h>
 #include <string>
 #include <strstream>
 

openmp/trunk/runtime/src/kmp.h

 /*! \file */
 /*
  * kmp.h -- KPTS runtime header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_H
 #define KMP_H
 
 #include "kmp_config.h"
 
 /* #define BUILD_PARALLEL_ORDERED 1 */
 
 /* This fix replaces gettimeofday with clock_gettime for better scalability on

openmp/trunk/runtime/src/kmp_affinity.h

 /*
  * kmp_affinity.h -- header for affinity management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_AFFINITY_H
 #define KMP_AFFINITY_H
 
 #include "kmp.h"
 #include "kmp_os.h"
 
 #if KMP_AFFINITY_SUPPORTED
 #if KMP_USE_HWLOC

openmp/trunk/runtime/src/kmp_affinity.cpp

 /*
  * kmp_affinity.cpp -- affinity management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 
 // Store the real or imagined machine hierarchy here
 static hierarchy_info machine_hierarchy;
 
 void __kmp_cleanup_hierarchy() { machine_hierarchy.fini(); }
 
-
 void __kmp_get_hierarchy(kmp_uint32 nproc, kmp_bstate_t *thr_bar) {
   kmp_uint32 depth;
   // The test below is true if affinity is available, but set to "none". Need to
   // init on first use of hierarchical barrier.
   if (TCR_1(machine_hierarchy.uninitialized))
     machine_hierarchy.init(NULL, nproc);
 
   // Adjust the hierarchy in case num threads exceeds original

openmp/trunk/runtime/src/kmp_alloc.cpp

 /*
  * kmp_alloc.cpp -- private/shared dynamic memory allocation and management
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_wrapper_malloc.h"
 
 // Disable bget when it is not used
 #if KMP_USE_BGET
 
 /* Thread private buffer management code */

openmp/trunk/runtime/src/kmp_atomic.h

 /*
  * kmp_atomic.h - ATOMIC header file
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ATOMIC_H
 #define KMP_ATOMIC_H
 
 #include "kmp_lock.h"
 #include "kmp_os.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"

openmp/trunk/runtime/src/kmp_atomic.cpp

 /*
  * kmp_atomic.cpp -- ATOMIC implementation routines
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_atomic.h"
 #include "kmp.h" // TRUE, asm routines prototypes
 
 typedef unsigned char uchar;
 typedef unsigned short ushort;
 
 /*!
 @defgroup ATOMIC_OPS Atomic Operations

openmp/trunk/runtime/src/kmp_barrier.cpp

 /*
  * kmp_barrier.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_wait_release.h"
 #include "kmp_itt.h"
 #include "kmp_os.h"
 #include "kmp_stats.h"
 
-
 #if KMP_MIC
 #include <immintrin.h>
 #define USE_NGO_STORES 1
 #endif // KMP_MIC
 
 #include "tsan_annotations.h"
 
 #if KMP_MIC && USE_NGO_STORES
if (!KMP_MASTER_TID(tid)) {
     ANNOTATE_BARRIER_BEGIN(this_thr);
     kmp_flag_64 flag(&thr_bar->b_arrived, other_threads[0]);
     flag.release();
   } else {
     kmp_balign_team_t *team_bar = &team->t.t_bar[bt];
     int nproc = this_thr->th.th_team_nproc;
     int i;
     // Don't have to worry about sleep bit here or atomic since team setting
-    kmp_uint64 new_state =
-        team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
+    kmp_uint64 new_state = team_bar->b_arrived + KMP_BARRIER_STATE_BUMP;
 
     // Collect all the worker team member threads.
     for (i = 1; i < nproc; ++i) {
 #if KMP_CACHE_MANAGE
       // Prefetch next thread's arrived count
       if (i + 1 < nproc)
         KMP_CACHE_PREFETCH(&other_threads[i + 1]->th.th_bar[bt].bb.b_arrived);
 #endif /* KMP_CACHE_MANAGE */

openmp/trunk/runtime/src/kmp_cancel.cpp

 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_str.h"
 
 #if OMP_40_ENABLED
 
 /*!

openmp/trunk/runtime/src/kmp_csupport.cpp

 /*
  * kmp_csupport.cpp -- kfront linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "omp.h" /* extern "C" declarations of user-visible routines */
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 

openmp/trunk/runtime/src/kmp_debug.h

 /*
  * kmp_debug.h -- debug / assertion code for Assure library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_DEBUG_H
 #define KMP_DEBUG_H
 
 #include <stdarg.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus

openmp/trunk/runtime/src/kmp_debug.cpp

 /*
  * kmp_debug.cpp -- debug utilities for the Guide library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_debug.h" /* really necessary? */
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 
 #ifdef KMP_DEBUG
 void __kmp_debug_printf_stdout(char const *format, ...) {
   va_list ap;

openmp/trunk/runtime/src/kmp_debugger.h

 #if USE_DEBUGGER
 /*
  * kmp_debugger.h -- debugger support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_DEBUGGER_H
 #define KMP_DEBUGGER_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 /* This external variable can be set by any debugger to flag to the runtime

openmp/trunk/runtime/src/kmp_debugger.cpp

 #if USE_DEBUGGER
 /*
  * kmp_debugger.cpp -- debugger support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_lock.h"
 #include "kmp_omp.h"
 #include "kmp_str.h"
 
 // NOTE: All variable names are known to the debugger, do not change!
 
 #ifdef __cplusplus

openmp/trunk/runtime/src/kmp_dispatch.cpp

 /*
  * kmp_dispatch.cpp: dynamic scheduling - iteration initialization and dispatch.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Dynamic scheduling initialization and dispatch.
  *
  * NOTE: __kmp_nth is a constant inside of any dispatch loop, however
  *       it may change values between parallel regions.  __kmp_max_nth
  *       is the largest value __kmp_nth may take, 1 is the smallest.
  */
 
 // Need to raise Win version from XP to Vista here for support of
#endif
             // nothing to do, don't try atomic op
             status = 0;
             break;
           }
           if ((T)remaining <
               pr->u.p.parm2) { // compare with K*nproc*(chunk+1), K=2 by default
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>(
-                RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunkspec);
+            init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+                                     (ST)chunkspec);
             remaining = trip - init;
             if (remaining <= 0) {
               status = 0; // all iterations got by other threads
             } else { // got some iterations to work on
               status = 1;
               if ((T)remaining > chunkspec) {
                 limit = init + chunkspec - 1;
               } else {
#endif
             status = 0; // nothing to do, don't try atomic op
             break;
           }
           KMP_DEBUG_ASSERT(init % chunk == 0);
           // compare with K*nproc*(chunk+1), K=2 by default
           if ((T)remaining < pr->u.p.parm2) {
             // use dynamic-style shcedule
             // atomically inrement iterations, get old value
-            init = test_then_add<ST>(
-                RCAST(volatile ST *, &sh->u.s.iteration), (ST)chunk);
+            init = test_then_add<ST>(RCAST(volatile ST *, &sh->u.s.iteration),
+                                     (ST)chunk);
             remaining = trip - init;
             if (remaining <= 0) {
               status = 0; // all iterations got by other threads
             } else {
               // got some iterations to work on
               status = 1;
               if ((T)remaining > chunk) {
                 limit = init + chunk - 1;

openmp/trunk/runtime/src/kmp_environment.h

 /*
  * kmp_environment.h -- Handle environment varoiables OS-independently.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ENVIRONMENT_H
 #define KMP_ENVIRONMENT_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 // Return a copy of the value of environment variable or NULL if the variable

openmp/trunk/runtime/src/kmp_environment.cpp

 /*
  * kmp_environment.cpp -- Handle environment variables OS-independently.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* We use GetEnvironmentVariable for Windows* OS instead of getenv because the
    act of loading a DLL on Windows* OS makes any user-set environment variables
    (i.e. with putenv()) unavailable.  getenv() apparently gets a clean copy of
    the env variables as they existed at the start of the run. JH 12/23/2002
 
    On Windows* OS, there are two environments (at least, see below):
 
    1. Environment maintained by Windows* OS on IA-32 architecture. Accessible

openmp/trunk/runtime/src/kmp_error.h

 /*
  * kmp_error.h -- PTS functions for error checking at runtime.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ERROR_H
 #define KMP_ERROR_H
 
 #include "kmp_i18n.h"
 
 /* ------------------------------------------------------------------------ */
 #ifdef __cplusplus
 extern "C" {

openmp/trunk/runtime/src/kmp_error.cpp

 /*
  * kmp_error.cpp -- KPTS functions for error checking at runtime
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 
 /* ------------------------------------------------------------------------ */
 
 #define MIN_STACK 100

openmp/trunk/runtime/src/kmp_ftn_cdecl.cpp

 /*
  * kmp_ftn_cdecl.cpp -- Fortran __cdecl linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 #if KMP_OS_WINDOWS
 #if defined KMP_WIN_CDECL || !defined KMP_DYNAMIC_LIB
 #define KMP_FTN_ENTRIES KMP_FTN_UPPER
 #endif
 #elif KMP_OS_UNIX

openmp/trunk/runtime/src/kmp_ftn_entry.h

 /*
  * kmp_ftn_entry.h -- Fortran entry linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef FTN_STDCALL
 #error The support file kmp_ftn_entry.h should not be compiled by itself.
 #endif
 
 #ifdef KMP_STUB
 #include "kmp_stub.h"
 #endif
 
if (!TCR_4(__kmp_init_parallel)) {
     return 0;
   }
   return __kmp_entry_thread()->th.th_current_task->td_flags.final;
 #endif
 }
 
 #if OMP_40_ENABLED
 
-
 kmp_proc_bind_t FTN_STDCALL xexpand(FTN_GET_PROC_BIND)(void) {
 #ifdef KMP_STUB
   return __kmps_get_proc_bind();
 #else
   return get__proc_bind(__kmp_entry_thread());
 #endif
 }
 
#ifdef PASS_ARGS_BY_VALUE
   int len = (int)KMP_STRLEN(str);
 #endif
   __kmp_aux_set_defaults(str, len);
 #endif
 }
 
 /* ------------------------------------------------------------------------ */
 
-
 #if OMP_40_ENABLED
 /* returns the status of cancellation */
 int FTN_STDCALL xexpand(FTN_GET_CANCELLATION)(void) {
 #ifdef KMP_STUB
   return 0 /* false */;
 #else
   // initialize the library if needed
   if (!__kmp_init_serial) {

openmp/trunk/runtime/src/kmp_ftn_extra.cpp

 /*
  * kmp_ftn_extra.cpp -- Fortran 'extra' linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 #if KMP_OS_WINDOWS
 #define KMP_FTN_ENTRIES KMP_FTN_PLAIN
 #elif KMP_OS_UNIX
 #define KMP_FTN_ENTRIES KMP_FTN_APPEND
 #endif

openmp/trunk/runtime/src/kmp_ftn_os.h

 /*
  * kmp_ftn_os.h -- KPTS Fortran defines header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_FTN_OS_H
 #define KMP_FTN_OS_H
 
 // KMP_FNT_ENTRIES may be one of: KMP_FTN_PLAIN, KMP_FTN_UPPER, KMP_FTN_APPEND,
 // KMP_FTN_UAPPEND.
 
 /* -------------------------- External definitions ------------------------ */
 

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES omp_get_num_devices_
 #endif
 #define FTN_GET_DEFAULT_DEVICE omp_get_default_device_
 #define FTN_SET_DEFAULT_DEVICE omp_set_default_device_
 #define FTN_IS_INITIAL_DEVICE omp_is_initial_device_
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION omp_get_cancellation_
 #define FTN_GET_CANCELLATION_STATUS kmp_get_cancellation_status_
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY omp_get_max_task_priority_
 #define FTN_GET_NUM_PLACES omp_get_num_places_

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES OMP_GET_NUM_DEVICES
 #endif
 #define FTN_GET_DEFAULT_DEVICE OMP_GET_DEFAULT_DEVICE
 #define FTN_SET_DEFAULT_DEVICE OMP_SET_DEFAULT_DEVICE
 #define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION OMP_GET_CANCELLATION
 #define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY
 #define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES

 #if KMP_MIC || KMP_OS_DARWIN || defined(KMP_STUB)
 #define FTN_GET_NUM_DEVICES OMP_GET_NUM_DEVICES_
 #endif
 #define FTN_GET_DEFAULT_DEVICE OMP_GET_DEFAULT_DEVICE_
 #define FTN_SET_DEFAULT_DEVICE OMP_SET_DEFAULT_DEVICE_
 #define FTN_IS_INITIAL_DEVICE OMP_IS_INITIAL_DEVICE_
 #endif
 
-
 #if OMP_40_ENABLED
 #define FTN_GET_CANCELLATION OMP_GET_CANCELLATION_
 #define FTN_GET_CANCELLATION_STATUS KMP_GET_CANCELLATION_STATUS_
 #endif
 
 #if OMP_45_ENABLED
 #define FTN_GET_MAX_TASK_PRIORITY OMP_GET_MAX_TASK_PRIORITY_
 #define FTN_GET_NUM_PLACES OMP_GET_NUM_PLACES_

openmp/trunk/runtime/src/kmp_ftn_stdcall.cpp

 /*
  * kmp_ftn_stdcall.cpp -- Fortran __stdcall linkage support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 
 // Note: This string is not printed when KMP_VERSION=1.
 char const __kmp_version_ftnstdcall[] =
     KMP_VERSION_PREFIX "Fortran __stdcall OMP support: "
 #ifdef USE_FTN_STDCALL
                        "yes";
 #else

openmp/trunk/runtime/src/kmp_global.cpp

 /*
  * kmp_global.cpp -- KPTS global variables for runtime support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 
 kmp_key_t __kmp_gtid_threadprivate_key;
 
 #if KMP_ARCH_X86 || KMP_ARCH_X86_64
 kmp_cpuinfo_t __kmp_cpuinfo = {0}; // Not initialized
 #endif

 #endif // KMP_FAST_REDUCTION_BARRIER
 };
 char const *__kmp_barrier_pattern_name[bp_last_bar] = {"linear", "tree",
                                                        "hyper", "hierarchical"};
 
 int __kmp_allThreadsSpecified = 0;
 size_t __kmp_align_alloc = CACHE_LINE;
 
-
 int __kmp_generate_warnings = kmp_warnings_low;
 int __kmp_reserve_warn = 0;
 int __kmp_xproc = 0;
 int __kmp_avail_proc = 0;
 size_t __kmp_sys_min_stksize = KMP_MIN_STKSIZE;
 int __kmp_sys_max_nth = KMP_MAX_NTH;
 int __kmp_max_nth = 0;
 int __kmp_cg_max_nth = 0;

openmp/trunk/runtime/src/kmp_gsupport.cpp

 /*
  * kmp_gsupport.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_atomic.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"
 #endif
 
 #ifdef __cplusplus

openmp/trunk/runtime/src/kmp_i18n.h

 /*
  * kmp_i18n.h
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_I18N_H
 #define KMP_I18N_H
 
 #include "kmp_str.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus

openmp/trunk/runtime/src/kmp_i18n.cpp

 /*
  * kmp_i18n.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_i18n.h"
 
 #include "kmp.h"
 #include "kmp_debug.h"
 #include "kmp_io.h" // __kmp_printf.
 #include "kmp_lock.h"
 #include "kmp_os.h"
 

openmp/trunk/runtime/src/kmp_import.cpp

 /*
  * kmp_import.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Object generated from this source file is linked to Windows* OS DLL import
    library (libompmd.lib) only! It is not a part of regular static or dynamic
    OpenMP RTL. Any code that just needs to go in the libompmd.lib (but not in
    libompmt.lib and libompmd.dll) should be placed in this file. */
 
 #ifdef __cplusplus
 extern "C" {
 #endif

openmp/trunk/runtime/src/kmp_io.h

 /*
  * kmp_io.h -- RTL IO header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_IO_H
 #define KMP_IO_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* ------------------------------------------------------------------------ */

openmp/trunk/runtime/src/kmp_io.cpp

 /*
  * kmp_io.cpp -- RTL IO
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stdarg.h>
 #include <stddef.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #ifndef __ABSOFT_WIN
 #include <sys/types.h>
 #endif

openmp/trunk/runtime/src/kmp_itt.h

 #if USE_ITT_BUILD
 /*
  * kmp_itt.h -- ITT Notify interface.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_ITT_H
 #define KMP_ITT_H
 
 #include "kmp_lock.h"
 
 #define INTEL_ITTNOTIFY_API_PRIVATE
 #include "ittnotify.h"
 #include "legacy/ittnotify.h"

openmp/trunk/runtime/src/kmp_itt.cpp

 #include "kmp_config.h"
 
 #if USE_ITT_BUILD
 /*
  * kmp_itt.cpp -- ITT Notify interface.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_itt.h"
 
 #if KMP_DEBUG
 #include "kmp_itt.inl"
 #endif
 
 #if USE_ITT_NOTIFY
 

openmp/trunk/runtime/src/kmp_itt.inl

 #if USE_ITT_BUILD
 /*
  * kmp_itt.inl -- Inline functions of ITT Notify.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 // Inline function definitions. This file should be included into kmp_itt.h file
 // for production build (to let compliler inline functions) or into kmp_itt.c
 // file for debug build (to reduce the number of files to recompile and save
 // build time).
 
 #include "kmp.h"
 #include "kmp_str.h"
 

openmp/trunk/runtime/src/kmp_lock.h

 /*
  * kmp_lock.h -- lock header file
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_LOCK_H
 #define KMP_LOCK_H
 
 #include <limits.h> // CHAR_BIT
 #include <stddef.h> // offsetof
 
 #include "kmp_debug.h"
 #include "kmp_os.h"

openmp/trunk/runtime/src/kmp_lock.cpp

 /*
  * kmp_lock.cpp -- lock-related functions
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stddef.h>
 #include <atomic>
 
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"

openmp/trunk/runtime/src/kmp_omp.h

 #if USE_DEBUGGER
 /*
  * kmp_omp.h -- OpenMP definition for kmp_omp_struct_info_t.
  *              This is for information about runtime library structures.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* THIS FILE SHOULD NOT BE MODIFIED IN IDB INTERFACE LIBRARY CODE
    It should instead be modified in the OpenMP runtime and copied to the
    interface library code.  This way we can minimize the problems that this is
    sure to cause having two copies of the same file.
 
    Files live in libomp and libomp_db/src/include  */
 
 /* CHANGE THIS WHEN STRUCTURES BELOW CHANGE

openmp/trunk/runtime/src/kmp_os.h

 /*
  * kmp_os.h -- KPTS runtime header file.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_OS_H
 #define KMP_OS_H
 
 #include "kmp_config.h"
 #include <stdlib.h>
 
 #define KMP_FTN_PLAIN 1
 #define KMP_FTN_APPEND 2

 #if __GNUC__ >= 4
 #define __forceinline __inline
 #endif
 
 #if KMP_OS_WINDOWS
 #include <windows.h>
 
 static inline int KMP_GET_PAGE_SIZE(void) {
-    SYSTEM_INFO si;
-    GetSystemInfo(&si);
-    return si.dwPageSize;
 }
 #else
 #define KMP_GET_PAGE_SIZE() getpagesize()
 #endif
 
 #define PAGE_ALIGNED(_addr)                                                    \
   (!((size_t)_addr & (size_t)(KMP_GET_PAGE_SIZE() - 1)))
 #define ALIGN_TO_PAGE(x)                                                       \

 #define STATIC_EFI2_WORKAROUND static
 #endif
 
 // Support of BGET usage
 #ifndef KMP_USE_BGET
 #define KMP_USE_BGET 1
 #endif
 
-
 // Switches for OSS builds
 #ifndef USE_SYSFS_INFO
 #define USE_SYSFS_INFO 0
 #endif
 #ifndef USE_CMPXCHG_FIX
 #define USE_CMPXCHG_FIX 1
 #endif
 

openmp/trunk/runtime/src/kmp_platform.h

 /*
  * kmp_platform.h -- header for determining operating system and architecture
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_PLATFORM_H
 #define KMP_PLATFORM_H
 
 /* ---------------------- Operating system recognition ------------------- */
 
 #define KMP_OS_LINUX 0
 #define KMP_OS_FREEBSD 0
 #define KMP_OS_NETBSD 0

openmp/trunk/runtime/src/kmp_runtime.cpp

 /*
  * kmp_runtime.cpp -- KPTS runtime support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_atomic.h"
 #include "kmp_environment.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
if (__kmp_inherit_fp_control) {
     kmp_int16 x87_fpu_control_word;
     kmp_uint32 mxcsr;
 
     // Get master values of FPU control flags (both X87 and vector)
     __kmp_store_x87_fpu_control_word(&x87_fpu_control_word);
     __kmp_store_mxcsr(&mxcsr);
     mxcsr &= KMP_X86_MXCSR_MASK;
 
     // There is no point looking at t_fp_control_saved here.
-// If it is TRUE, we still have to update the values if they are different from
-// those we now have.
-// If it is FALSE we didn't save anything yet, but our objective is the same. We
-// have to ensure that the values in the team are the same as those we have.
+    // If it is TRUE, we still have to update the values if they are different
+    // from those we now have. If it is FALSE we didn't save anything yet, but
+    // our objective is the same. We have to ensure that the values in the team
+    // are the same as those we have.
     // So, this code achieves what we need whether or not t_fp_control_saved is
     // true. By checking whether the value needs updating we avoid unnecessary
     // writes that would put the cache-line into a written state, causing all
     // threads in the team to have to read it again.
     KMP_CHECK_UPDATE(team->t.t_x87_fpu_control_word, x87_fpu_control_word);
     KMP_CHECK_UPDATE(team->t.t_mxcsr, mxcsr);
     // Although we don't use this value, other code in the runtime wants to know
     // whether it should restore them. So we must ensure it is correct.
     KMP_CHECK_UPDATE(team->t.t_fp_control_saved, TRUE);
   } else {
     // Similarly here. Don't write to this cache-line in the team structure
     // unless we have to.
if (n_th <= n_places) {
           if (place == last_place) {
             place = first_place;
           } else if (place == (int)(__kmp_affinity_num_masks - 1)) {
             place = 0;
           } else {
             place++;
           }
 
-          KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
-                         "partition = [%d,%d], __kmp_affinity_num_masks: %u\n",
-                         __kmp_gtid_from_thread(team->t.t_threads[f]),
-                         team->t.t_id, f, th->th.th_new_place,
-                         th->th.th_first_place, th->th.th_last_place,
-                         __kmp_affinity_num_masks));
+          KA_TRACE(100,
+                   ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+                    __kmp_gtid_from_thread(team->t.t_threads[f]), team->t.t_id,
+                    f, th->th.th_new_place, th->th.th_first_place,
+                    th->th.th_last_place, __kmp_affinity_num_masks));
         }
       } else {
         /* Having uniform space of available computation places I can create
            T partitions of round(P/T) size and put threads into the first
            place of each partition. */
         double current = static_cast<double>(masters_place);
         double spacing =
-                (static_cast<double>(n_places + 1) / static_cast<double>(n_th));
         int first, last;
         kmp_info_t *th;
 
         thidx = n_th + 1;
         if (update_master_only == 1)
           thidx = 1;
         for (f = 0; f < thidx; f++) {
           first = static_cast<int>(current);
if (n_th <= n_places) {
             KMP_DEBUG_ASSERT(n_places > last);
             KMP_DEBUG_ASSERT(last_place >= first_place);
             th = team->t.t_threads[f];
             KMP_DEBUG_ASSERT(th);
             th->th.th_first_place = first;
             th->th.th_new_place = place;
             th->th.th_last_place = last;
 
-            KA_TRACE(100, ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
-                           "partition = [%d,%d], spacing = %.4f\n",
-                           __kmp_gtid_from_thread(team->t.t_threads[f]),
-                           team->t.t_id, f, th->th.th_new_place,
-                           th->th.th_first_place, th->th.th_last_place,
-                           spacing));
+            KA_TRACE(100,
+                     ("__kmp_partition_places: spread: T#%d(%d:%d) place %d "
+                      th->th.th_first_place, th->th.th_last_place, spacing));
           }
         }
       }
       KMP_DEBUG_ASSERT(update_master_only || place == masters_place);
     } else {
       int S, rem, gap, s_count;
       S = n_th / n_places;
       s_count = 0;
#if OMPT_SUPPORT
       __ompt_team_assign_id(team, ompt_parallel_id);
 #endif
 
       KMP_MB();
 
       return team;
     }
 
     /* reap team if it is too small, then loop back and check the next one */
-// not sure if this is wise, but, will be redone during the hot-teams rewrite.
+    // not sure if this is wise, but, will be redone during the hot-teams
+    // rewrite.
     /* TODO: Use technique to find the right size hot-team, don't reap them */
     team = __kmp_reap_team(team);
     __kmp_team_pool = team;
   }
 
   /* nothing available in the pool, no matter, make a new team! */
   KMP_MB();
   team = (kmp_team_t *)__kmp_allocate(sizeof(kmp_team_t));
 
#endif
   KMP_MB(); /* Flush all pending memory write invalidates.  */
   TCW_SYNC_4(__kmp_global.g.g_done, TRUE);
 
   if (i < __kmp_threads_capacity) {
 #if KMP_USE_MONITOR
     // 2009-09-08 (lev): Other alive roots found. Why do we kill the monitor??
     KMP_MB(); /* Flush all pending memory write invalidates.  */
 
     // Need to check that monitor was initialized before reaping it. If we are
     // called form __kmp_atfork_child (which sets __kmp_init_parallel = 0), then
-// __kmp_monitor will appear to contain valid data, but it is only valid in the
-// parent process, not the child.
+    // __kmp_monitor will appear to contain valid data, but it is only valid in
+    // the parent process, not the child.
     // New behavior (201008): instead of keying off of the flag
     // __kmp_init_parallel, the monitor thread creation is keyed off
     // of the new flag __kmp_init_monitor.
     __kmp_acquire_bootstrap_lock(&__kmp_monitor_lock);
     if (TCR_4(__kmp_init_monitor)) {
       __kmp_reap_monitor(&__kmp_monitor);
       TCW_4(__kmp_init_monitor, 0);
     }

openmp/trunk/runtime/src/kmp_safe_c_api.h

 
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_SAFE_C_API_H
 #define KMP_SAFE_C_API_H
 
 // Replacement for banned C API
 
 // Not every unsafe call listed here is handled now, but keeping everything
 // in one place should be handy for future maintenance.
 #if KMP_OS_WINDOWS

openmp/trunk/runtime/src/kmp_sched.cpp

 /*
  * kmp_sched.cpp -- static scheduling -- iteration initialization
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 /* Static scheduling initialization.
 
   NOTE: team->t.t_nproc is a constant inside of any dispatch loop, however
         it may change values between parallel regions.  __kmp_max_nth
         is the largest value __kmp_nth may take, 1 is the smallest. */
 
 #include "kmp.h"
 #include "kmp_error.h"

openmp/trunk/runtime/src/kmp_settings.h

 /*
  * kmp_settings.h -- Initialize environment variables
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_SETTINGS_H
 #define KMP_SETTINGS_H
 
 void __kmp_reset_global_vars(void);
 void __kmp_env_initialize(char const *);
 void __kmp_env_print();
 #if OMP_40_ENABLED
 void __kmp_env_print_2();

openmp/trunk/runtime/src/kmp_settings.cpp

 /*
  * kmp_settings.cpp -- Initialize environment variables
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_atomic.h"
 #include "kmp_environment.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_settings.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
-#include <ctype.h>   // toupper()
+#include <ctype.h> // toupper()
 
 static int __kmp_env_toPrint(char const *name, int flag);
 
 bool __kmp_env_format = 0; // 0 - old format; 1 - new format
 
 // -----------------------------------------------------------------------------
 // Helper string functions. Subject to move to kmp_str.
 
if (value) {
     ompc_set_nested(__kmp_dflt_nested);
   }
 
   /* OMP_DYNAMIC */
   value = __kmp_env_blk_var(block, "OMP_DYNAMIC");
   if (value) {
     ompc_set_dynamic(__kmp_global.g.g_dynamic);
   }
-
 }
 
 void __kmp_env_initialize(char const *string) {
 
   kmp_env_blk_t block;
   int i;
 
   __kmp_stg_init();
if (block.vars[i].value == NULL) {
       continue;
     }
     kmp_setting_t *setting = __kmp_stg_find(block.vars[i].name);
     if (setting != NULL) {
       setting->set = 1;
     }
   }
 
   // We need to know if blocktime was set when processing OMP_WAIT_POLICY
   blocktime_str = __kmp_env_blk_var(&block, "KMP_BLOCKTIME");
 
   // Special case. If we parse environment, not a string, process KMP_WARNINGS
   // first.
   if (string == NULL) {
     char const *name = "KMP_WARNINGS";
     char const *value = __kmp_env_blk_var(&block, name);
     __kmp_stg_parse(name, value);

openmp/trunk/runtime/src/kmp_stats.h

 #ifndef KMP_STATS_H
 #define KMP_STATS_H
 
 /** @file kmp_stats.h
  * Functions for collecting statistics.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_config.h"
 
 #if KMP_STATS_ENABLED
 /* Statistics accumulator.
    Accumulates number of samples and computes min, max, mean, standard deviation
    on the fly.
 
    Online variance calculation algorithm from

openmp/trunk/runtime/src/kmp_stats.cpp

 /** @file kmp_stats.cpp
  * Statistics gathering and processing.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
 
 #include <algorithm>
 #include <ctime>
 #include <iomanip>

openmp/trunk/runtime/src/kmp_stats_timing.h

 #ifndef KMP_STATS_TIMING_H
 #define KMP_STATS_TIMING_H
 
 /** @file kmp_stats_timing.h
  * Access to real time clock and timers.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_os.h"
 #include <limits>
 #include <stdint.h>
 #include <string>
 #if KMP_HAVE_X86INTRIN_H
 #include <x86intrin.h>
 #endif
 
#endif
     friend tsc_interval_t &operator+=(tsc_tick_count::tsc_interval_t &i1,
                                       const tsc_tick_count::tsc_interval_t &i0);
   };
 
 #if KMP_HAVE___BUILTIN_READCYCLECOUNTER
   tsc_tick_count()
       : my_count(static_cast<int64_t>(__builtin_readcyclecounter())) {}
 #elif KMP_HAVE___RDTSC
-  tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())){}
+  tsc_tick_count() : my_count(static_cast<int64_t>(__rdtsc())) {}
 #else
 #error Must have high resolution timer defined
 #endif
-  tsc_tick_count(int64_t value) : my_count(value){}
+  tsc_tick_count(int64_t value) : my_count(value) {}
   int64_t getValue() const { return my_count; }
   tsc_tick_count later(tsc_tick_count const other) const {
     return my_count > other.my_count ? (*this) : other;
   }
   tsc_tick_count earlier(tsc_tick_count const other) const {
     return my_count < other.my_count ? (*this) : other;
   }
 #if KMP_HAVE_TICK_TIME

openmp/trunk/runtime/src/kmp_stats_timing.cpp

 /** @file kmp_stats_timing.cpp
  * Timing functions
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <stdlib.h>
 #include <unistd.h>
 
 #include <iomanip>
 #include <iostream>
 #include <sstream>
 
 #include "kmp.h"

openmp/trunk/runtime/src/kmp_str.h

 /*
  * kmp_str.h -- String manipulation routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_STR_H
 #define KMP_STR_H
 
 #include <stdarg.h>
 #include <string.h>
 
 #include "kmp_os.h"
 

openmp/trunk/runtime/src/kmp_str.cpp

 /*
  * kmp_str.cpp -- String manipulation routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp_str.h"
 
 #include <stdarg.h> // va_*
 #include <stdio.h> // vsnprintf()
 #include <stdlib.h> // malloc(), realloc()
 
 #include "kmp.h"
 #include "kmp_i18n.h"

openmp/trunk/runtime/src/kmp_stub.h

 /*
  * kmp_stub.h
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_STUB_H
 #define KMP_STUB_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 void __kmps_set_blocktime(int arg);

openmp/trunk/runtime/src/kmp_stub.cpp

 /*
  * kmp_stub.cpp -- stub versions of user-callable OpenMP RT functions.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include <errno.h>
 #include <limits.h>
 #include <stdlib.h>
 
 #include "kmp.h" // KMP_DEFAULT_STKSIZE
 #include "kmp_stub.h"
 #include "omp.h" // Function renamings.
 

openmp/trunk/runtime/src/kmp_taskdeps.cpp

 /*
  * kmp_taskdeps.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 //#define KMP_SUPPORT_GRAPH_OUTPUT 1
 
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_wait_release.h"
 
 #if OMP_40_ENABLED
 

openmp/trunk/runtime/src/kmp_tasking.cpp

 /*
  * kmp_tasking.cpp -- OpenMP 3.0 tasking support.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 #include "kmp_wait_release.h"
 
 #if OMPT_SUPPORT
 #include "ompt-specific.h"

openmp/trunk/runtime/src/kmp_taskq.cpp

 /*
  * kmp_taskq.cpp -- TASKQ support for OpenMP.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_error.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 
 #define MAX_MESSAGE 512
 
 /* Taskq routines and global variables */

openmp/trunk/runtime/src/kmp_threadprivate.cpp

 /*
  * kmp_threadprivate.cpp -- OpenMP threadprivate support library
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_itt.h"
 
 #define USE_CHECKS_COMMON
 
 #define KMP_INLINE_SUBR 1
 

openmp/trunk/runtime/src/kmp_utility.cpp

 /*
  * kmp_utility.cpp -- Utility routines for the OpenMP support library.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_i18n.h"
 #include "kmp_str.h"
 #include "kmp_wrapper_getpid.h"
 #include <float.h>
 
 static const char *unknown = "unknown";
 

openmp/trunk/runtime/src/kmp_version.h

 /*
  * kmp_version.h -- version number for this release
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_VERSION_H
 #define KMP_VERSION_H
 
 #ifdef __cplusplus
 extern "C" {
 #endif // __cplusplus
 
 #ifndef KMP_VERSION_MAJOR

openmp/trunk/runtime/src/kmp_version.cpp

 /*
  * kmp_version.cpp
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_io.h"
 #include "kmp_version.h"
 
 // Replace with snapshot date YYYYMMDD for promotion build.
 #define KMP_VERSION_BUILD 20140926
 
 // Helper macros to convert value of macro to string literal.

openmp/trunk/runtime/src/kmp_wait_release.h

 /*
  * kmp_wait_release.h -- Wait/Release implementation
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WAIT_RELEASE_H
 #define KMP_WAIT_RELEASE_H
 
 #include "kmp.h"
 #include "kmp_itt.h"
 #include "kmp_stats.h"
 
 /*!

openmp/trunk/runtime/src/kmp_wait_release.cpp

 /*
  * kmp_wait_release.cpp -- Wait/Release implementation
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//

openmp/trunk/runtime/src/kmp_wrapper_getpid.h

 /*
  * kmp_wrapper_getpid.h -- getpid() declaration.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WRAPPER_GETPID_H
 #define KMP_WRAPPER_GETPID_H
 
 #if KMP_OS_UNIX
 
 // On Unix-like systems (Linux* OS and OS X*) getpid() is declared in standard
 // headers.
 #include <sys/syscall.h>

openmp/trunk/runtime/src/kmp_wrapper_malloc.h

 /*
  * kmp_wrapper_malloc.h -- Wrappers for memory allocation routines
  *                         (malloc(), free(), and others).
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #ifndef KMP_WRAPPER_MALLOC_H
 #define KMP_WRAPPER_MALLOC_H
 
 /* This header serves for 3 purposes:
    1. Declaring standard memory allocation rourines in OS-independent way.
    2. Passing source location info through memory allocation wrappers.
    3. Enabling native memory debugging capabilities.
 

openmp/trunk/runtime/src/z_Linux_util.cpp

 /*
  * z_Linux_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_lock.h"
 #include "kmp_stats.h"
 #include "kmp_str.h"
if (th->th.th_suspend_init_count > __kmp_fork_count) {
     if (status != 0 && status != EBUSY) {
       KMP_SYSFAIL("pthread_mutex_destroy", status);
     }
     --th->th.th_suspend_init_count;
     KMP_DEBUG_ASSERT(th->th.th_suspend_init_count == __kmp_fork_count);
   }
 }
 
-
 /* This routine puts the calling thread to sleep after setting the
    sleep bit for the indicated flag variable to true. */
 template <class C>
 static inline void __kmp_suspend_template(int th_gtid, C *flag) {
   KMP_TIME_DEVELOPER_PARTITIONED_BLOCK(USER_suspend);
   kmp_info_t *th = __kmp_threads[th_gtid];
   int status;
   typename C::flag_t old_spin;

openmp/trunk/runtime/src/z_Windows_NT-586_util.cpp

 /*
  * z_Windows_NT-586_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 
 #if (KMP_ARCH_X86 || KMP_ARCH_X86_64)
 /* Only 32-bit "add-exchange" instruction on IA-32 architecture causes us to
    use compare_and_store for these routines */
 
 kmp_int8 __kmp_test_then_or8(volatile kmp_int8 *p, kmp_int8 d) {
   kmp_int8 old_value, new_value;

openmp/trunk/runtime/src/z_Windows_NT_util.cpp

 /*
  * z_Windows_NT_util.cpp -- platform specific routines.
  */
 
-
 //===----------------------------------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is dual licensed under the MIT and the University of Illinois Open
 // Source Licenses. See LICENSE.txt for details.
 //
 //===----------------------------------------------------------------------===//
 
-
 #include "kmp.h"
 #include "kmp_affinity.h"
 #include "kmp_i18n.h"
 #include "kmp_io.h"
 #include "kmp_itt.h"
 #include "kmp_wait_release.h"
 
 /* This code is related to NtQuerySystemInformation() function. This function