Restoring authorship annotation for Anton Samokhvalov <pg83@yandex.ru>. Commit 1 of 2.

1 files changed, 281 insertions, 281 deletions

diff --git a/contrib/libs/cxxsupp/openmp/kmp_cancel.cpp b/contrib/libs/cxxsupp/openmp/kmp_cancel.cpp
index d1eb00c664..17ea375cd0 100644
--- a/contrib/libs/cxxsupp/openmp/kmp_cancel.cpp
+++ b/contrib/libs/cxxsupp/openmp/kmp_cancel.cpp
@@ -1,282 +1,282 @@
-
-//===----------------------------------------------------------------------===//
-//
-//                     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
-
-/*!
-@ingroup CANCELLATION
-@param loc_ref location of the original task directive
-@param gtid Global thread ID of encountering thread
-@param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
-
-@return returns true if the cancellation request has been activated and the execution thread
-needs to proceed to the end of the canceled region.
-
-Request cancellation of the binding OpenMP region.
-*/
-kmp_int32 __kmpc_cancel(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
-    
-    KC_TRACE( 10, ("__kmpc_cancel: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) );
-
-    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
-    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop || 
-                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup); 
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
-
-    if (__kmp_omp_cancellation) {
-        switch (cncl_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            // cancellation requests for parallel and worksharing constructs
-            // are handled through the team structure
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                KMP_DEBUG_ASSERT(this_team);
-                kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(this_team->t.t_cancel_request), cancel_noreq, cncl_kind);
-                if (old == cancel_noreq || old == cncl_kind) {
-                    //printf("__kmpc_cancel: this_team->t.t_cancel_request=%d @ %p\n", 
-                    //       this_team->t.t_cancel_request, &(this_team->t.t_cancel_request));
-                    // we do not have a cancellation request in this team or we do have one
-                    // that matches the current request -> cancel
-                    return 1 /* true */;
-                }
-                break;
-            }
-        case cancel_taskgroup:
-            // cancellation requests for a task group
-            // are handled through the taskgroup structure
-            {
-                kmp_taskdata_t*  task; 
-                kmp_taskgroup_t* taskgroup;
-                
-                task = this_thr->th.th_current_task;
-                KMP_DEBUG_ASSERT( task );
-                
-                taskgroup = task->td_taskgroup;
-                if (taskgroup) {
-                    kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(taskgroup->cancel_request), cancel_noreq, cncl_kind);
-                    if (old == cancel_noreq || old == cncl_kind) {
-                        // we do not have a cancellation request in this taskgroup or we do have one
-                        // that matches the current request -> cancel
-                        return 1 /* true */;
-                    }
-                }
-                else {
-                    // TODO: what needs to happen here?
-                    // the specification disallows cancellation w/o taskgroups
-                    // so we might do anything here, let's abort for now
-                    KMP_ASSERT( 0 /* false */);
-                }
-            }
-            break;
-        default:
-            KMP_ASSERT (0 /* false */);
-        }
-    }
-
-    // ICV OMP_CANCELLATION=false, so we ignored this cancel request
-    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
-    return 0 /* false */;
-}
-
-/*!
-@ingroup CANCELLATION
-@param loc_ref location of the original task directive
-@param gtid Global thread ID of encountering thread
-@param cncl_kind Cancellation kind (parallel, for, sections, taskgroup)
-
-@return returns true if a matching cancellation request has been flagged in the RTL and the 
-encountering thread has to cancel..
-
-Cancellation point for the encountering thread.
-*/
-kmp_int32 __kmpc_cancellationpoint(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) {
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
-
-    KC_TRACE( 10, ("__kmpc_cancellationpoint: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) );
-
-    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq);
-    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop || 
-                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup); 
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
-
-    if (__kmp_omp_cancellation) {
-        switch (cncl_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            // cancellation requests for parallel and worksharing constructs
-            // are handled through the team structure
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                KMP_DEBUG_ASSERT(this_team);
-                if (this_team->t.t_cancel_request) {
-                    if (cncl_kind == this_team->t.t_cancel_request) {
-                        // the request in the team structure matches the type of
-                        // cancellation point so we can cancel
-                        return 1 /* true */;
-                    }
-                    KMP_ASSERT( 0 /* false */);
-                }
-                else {
-                    // we do not have a cancellation request pending, so we just
-                    // ignore this cancellation point
-                    return 0;
-                }
-                break;
-            }
-        case cancel_taskgroup:
-            // cancellation requests for a task group
-            // are handled through the taskgroup structure
-            {
-                kmp_taskdata_t*  task; 
-                kmp_taskgroup_t* taskgroup;
-                
-                task = this_thr->th.th_current_task;
-                KMP_DEBUG_ASSERT( task );
-                
-                taskgroup = task->td_taskgroup;
-                if (taskgroup) {
-                    // return the current status of cancellation for the 
-                    // taskgroup
-                    return !!taskgroup->cancel_request;
-                }
-                else {
-                    // if a cancellation point is encountered by a task
-                    // that does not belong to a taskgroup, it is OK
-                    // to ignore it
-                    return 0 /* false */;
-                }
-            }
-        default:
-            KMP_ASSERT (0 /* false */);
-        }
-    }
-
-    // ICV OMP_CANCELLATION=false, so we ignore the cancellation point
-    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation);
-    return 0 /* false */;
-}
-
-/*!
-@ingroup CANCELLATION
-@param loc_ref location of the original task directive
-@param gtid Global thread ID of encountering thread
-
-@return returns true if a matching cancellation request has been flagged in the RTL and the 
-encountering thread has to cancel..
-
-Barrier with cancellation point to send threads from the barrier to the
-end of the parallel region.  Needs a special code pattern as documented 
-in the design document for the cancellation feature.
-*/
-kmp_int32
-__kmpc_cancel_barrier(ident_t *loc, kmp_int32 gtid) {
-    int ret = 0 /* false */;
-    kmp_info_t *this_thr = __kmp_threads [ gtid ];
-    kmp_team_t *this_team = this_thr->th.th_team;
-
-    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid);
-
-    // call into the standard barrier
-    __kmpc_barrier(loc, gtid);
-
-    // if cancellation is active, check cancellation flag
-    if (__kmp_omp_cancellation) {
-        // depending on which construct to cancel, check the flag and
-        // reset the flag
-        switch (this_team->t.t_cancel_request) {
-        case cancel_parallel:
-            ret = 1;
-            // ensure that threads have checked the flag, when
-            // leaving the above barrier
-            __kmpc_barrier(loc, gtid);
-            this_team->t.t_cancel_request = cancel_noreq;
-            // the next barrier is the fork/join barrier, which
-            // synchronizes the threads leaving here        
-            break;
-        case cancel_loop:
-        case cancel_sections:
-            ret = 1;
-            // ensure that threads have checked the flag, when
-            // leaving the above barrier
-            __kmpc_barrier(loc, gtid);
-            this_team->t.t_cancel_request = cancel_noreq;
-            // synchronize the threads again to make sure we
-            // do not have any run-away threads that cause a race
-            // on the cancellation flag
-            __kmpc_barrier(loc, gtid);
-            break;
-        case cancel_taskgroup:
-            // this case should not occur
-            KMP_ASSERT (0 /* false */ );
-            break;
-        case cancel_noreq:
-            // do nothing
-            break;
-        default:
-            KMP_ASSERT ( 0 /* false */);
-        }
-    }
-    
-    return ret;
-}
-
-/*!
-@ingroup CANCELLATION
-@param loc_ref location of the original task directive
-@param gtid Global thread ID of encountering thread
-
-@return returns true if a matching cancellation request has been flagged in the RTL and the 
-encountering thread has to cancel..
-
-Query function to query the current status of cancellation requests.
-Can be used to implement the following pattern:
  
-if (kmp_get_cancellation_status(kmp_cancel_parallel)) {
-    perform_cleanup();
-    #pragma omp cancellation point parallel      
-}
-*/
-int __kmp_get_cancellation_status(int cancel_kind) {
-    if (__kmp_omp_cancellation) {
-        kmp_info_t *this_thr = __kmp_entry_thread();
-        
-        switch (cancel_kind) {
-        case cancel_parallel:
-        case cancel_loop:
-        case cancel_sections:
-            {
-                kmp_team_t *this_team = this_thr->th.th_team;
-                return this_team->t.t_cancel_request == cancel_kind;
-            }
-        case cancel_taskgroup:
-            {
-                kmp_taskdata_t*  task; 
-                kmp_taskgroup_t* taskgroup;
-                task = this_thr->th.th_current_task;
-                taskgroup = task->td_taskgroup;
-                return taskgroup && taskgroup->cancel_request;
-            }
-        }
-    }
-
-    return 0 /* false */;
-}
-
-#endif
+//===----------------------------------------------------------------------===// 
+// 
+//                     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 
+ 
+/*! 
+@ingroup CANCELLATION 
+@param loc_ref location of the original task directive 
+@param gtid Global thread ID of encountering thread 
+@param cncl_kind Cancellation kind (parallel, for, sections, taskgroup) 
+ 
+@return returns true if the cancellation request has been activated and the execution thread 
+needs to proceed to the end of the canceled region. 
+ 
+Request cancellation of the binding OpenMP region. 
+*/ 
+kmp_int32 __kmpc_cancel(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) { 
+    kmp_info_t *this_thr = __kmp_threads [ gtid ]; 
+     
+    KC_TRACE( 10, ("__kmpc_cancel: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) ); 
+ 
+    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq); 
+    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||  
+                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup);  
+    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid); 
+ 
+    if (__kmp_omp_cancellation) { 
+        switch (cncl_kind) { 
+        case cancel_parallel: 
+        case cancel_loop: 
+        case cancel_sections: 
+            // cancellation requests for parallel and worksharing constructs 
+            // are handled through the team structure 
+            { 
+                kmp_team_t *this_team = this_thr->th.th_team; 
+                KMP_DEBUG_ASSERT(this_team); 
+                kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(this_team->t.t_cancel_request), cancel_noreq, cncl_kind); 
+                if (old == cancel_noreq || old == cncl_kind) { 
+                    //printf("__kmpc_cancel: this_team->t.t_cancel_request=%d @ %p\n",  
+                    //       this_team->t.t_cancel_request, &(this_team->t.t_cancel_request)); 
+                    // we do not have a cancellation request in this team or we do have one 
+                    // that matches the current request -> cancel 
+                    return 1 /* true */; 
+                } 
+                break; 
+            } 
+        case cancel_taskgroup: 
+            // cancellation requests for a task group 
+            // are handled through the taskgroup structure 
+            { 
+                kmp_taskdata_t*  task;  
+                kmp_taskgroup_t* taskgroup; 
+                 
+                task = this_thr->th.th_current_task; 
+                KMP_DEBUG_ASSERT( task ); 
+                 
+                taskgroup = task->td_taskgroup; 
+                if (taskgroup) { 
+                    kmp_int32 old = KMP_COMPARE_AND_STORE_RET32(&(taskgroup->cancel_request), cancel_noreq, cncl_kind); 
+                    if (old == cancel_noreq || old == cncl_kind) { 
+                        // we do not have a cancellation request in this taskgroup or we do have one 
+                        // that matches the current request -> cancel 
+                        return 1 /* true */; 
+                    } 
+                } 
+                else { 
+                    // TODO: what needs to happen here? 
+                    // the specification disallows cancellation w/o taskgroups 
+                    // so we might do anything here, let's abort for now 
+                    KMP_ASSERT( 0 /* false */); 
+                } 
+            } 
+            break; 
+        default: 
+            KMP_ASSERT (0 /* false */); 
+        } 
+    } 
+ 
+    // ICV OMP_CANCELLATION=false, so we ignored this cancel request 
+    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation); 
+    return 0 /* false */; 
+} 
+ 
+/*! 
+@ingroup CANCELLATION 
+@param loc_ref location of the original task directive 
+@param gtid Global thread ID of encountering thread 
+@param cncl_kind Cancellation kind (parallel, for, sections, taskgroup) 
+ 
+@return returns true if a matching cancellation request has been flagged in the RTL and the  
+encountering thread has to cancel.. 
+ 
+Cancellation point for the encountering thread. 
+*/ 
+kmp_int32 __kmpc_cancellationpoint(ident_t* loc_ref, kmp_int32 gtid, kmp_int32 cncl_kind) { 
+    kmp_info_t *this_thr = __kmp_threads [ gtid ]; 
+ 
+    KC_TRACE( 10, ("__kmpc_cancellationpoint: T#%d request %d OMP_CANCELLATION=%d\n", gtid, cncl_kind, __kmp_omp_cancellation) ); 
+ 
+    KMP_DEBUG_ASSERT(cncl_kind != cancel_noreq); 
+    KMP_DEBUG_ASSERT(cncl_kind == cancel_parallel || cncl_kind == cancel_loop ||  
+                     cncl_kind == cancel_sections || cncl_kind == cancel_taskgroup);  
+    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid); 
+ 
+    if (__kmp_omp_cancellation) { 
+        switch (cncl_kind) { 
+        case cancel_parallel: 
+        case cancel_loop: 
+        case cancel_sections: 
+            // cancellation requests for parallel and worksharing constructs 
+            // are handled through the team structure 
+            { 
+                kmp_team_t *this_team = this_thr->th.th_team; 
+                KMP_DEBUG_ASSERT(this_team); 
+                if (this_team->t.t_cancel_request) { 
+                    if (cncl_kind == this_team->t.t_cancel_request) { 
+                        // the request in the team structure matches the type of 
+                        // cancellation point so we can cancel 
+                        return 1 /* true */; 
+                    } 
+                    KMP_ASSERT( 0 /* false */); 
+                } 
+                else { 
+                    // we do not have a cancellation request pending, so we just 
+                    // ignore this cancellation point 
+                    return 0; 
+                } 
+                break; 
+            } 
+        case cancel_taskgroup: 
+            // cancellation requests for a task group 
+            // are handled through the taskgroup structure 
+            { 
+                kmp_taskdata_t*  task;  
+                kmp_taskgroup_t* taskgroup; 
+                 
+                task = this_thr->th.th_current_task; 
+                KMP_DEBUG_ASSERT( task ); 
+                 
+                taskgroup = task->td_taskgroup; 
+                if (taskgroup) { 
+                    // return the current status of cancellation for the  
+                    // taskgroup 
+                    return !!taskgroup->cancel_request; 
+                } 
+                else { 
+                    // if a cancellation point is encountered by a task 
+                    // that does not belong to a taskgroup, it is OK 
+                    // to ignore it 
+                    return 0 /* false */; 
+                } 
+            } 
+        default: 
+            KMP_ASSERT (0 /* false */); 
+        } 
+    } 
+ 
+    // ICV OMP_CANCELLATION=false, so we ignore the cancellation point 
+    KMP_DEBUG_ASSERT(!__kmp_omp_cancellation); 
+    return 0 /* false */; 
+} 
+ 
+/*! 
+@ingroup CANCELLATION 
+@param loc_ref location of the original task directive 
+@param gtid Global thread ID of encountering thread 
+ 
+@return returns true if a matching cancellation request has been flagged in the RTL and the  
+encountering thread has to cancel.. 
+ 
+Barrier with cancellation point to send threads from the barrier to the 
+end of the parallel region.  Needs a special code pattern as documented  
+in the design document for the cancellation feature. 
+*/ 
+kmp_int32 
+__kmpc_cancel_barrier(ident_t *loc, kmp_int32 gtid) { 
+    int ret = 0 /* false */; 
+    kmp_info_t *this_thr = __kmp_threads [ gtid ]; 
+    kmp_team_t *this_team = this_thr->th.th_team; 
+ 
+    KMP_DEBUG_ASSERT(__kmp_get_gtid() == gtid); 
+ 
+    // call into the standard barrier 
+    __kmpc_barrier(loc, gtid); 
+ 
+    // if cancellation is active, check cancellation flag 
+    if (__kmp_omp_cancellation) { 
+        // depending on which construct to cancel, check the flag and 
+        // reset the flag 
+        switch (this_team->t.t_cancel_request) { 
+        case cancel_parallel: 
+            ret = 1; 
+            // ensure that threads have checked the flag, when 
+            // leaving the above barrier 
+            __kmpc_barrier(loc, gtid); 
+            this_team->t.t_cancel_request = cancel_noreq; 
+            // the next barrier is the fork/join barrier, which 
+            // synchronizes the threads leaving here         
+            break; 
+        case cancel_loop: 
+        case cancel_sections: 
+            ret = 1; 
+            // ensure that threads have checked the flag, when 
+            // leaving the above barrier 
+            __kmpc_barrier(loc, gtid); 
+            this_team->t.t_cancel_request = cancel_noreq; 
+            // synchronize the threads again to make sure we 
+            // do not have any run-away threads that cause a race 
+            // on the cancellation flag 
+            __kmpc_barrier(loc, gtid); 
+            break; 
+        case cancel_taskgroup: 
+            // this case should not occur 
+            KMP_ASSERT (0 /* false */ ); 
+            break; 
+        case cancel_noreq: 
+            // do nothing 
+            break; 
+        default: 
+            KMP_ASSERT ( 0 /* false */); 
+        } 
+    } 
+     
+    return ret; 
+} 
+ 
+/*! 
+@ingroup CANCELLATION 
+@param loc_ref location of the original task directive 
+@param gtid Global thread ID of encountering thread 
+ 
+@return returns true if a matching cancellation request has been flagged in the RTL and the  
+encountering thread has to cancel.. 
+ 
+Query function to query the current status of cancellation requests. 
+Can be used to implement the following pattern: 
+  
+if (kmp_get_cancellation_status(kmp_cancel_parallel)) { 
+    perform_cleanup(); 
+    #pragma omp cancellation point parallel       
+} 
+*/ 
+int __kmp_get_cancellation_status(int cancel_kind) { 
+    if (__kmp_omp_cancellation) { 
+        kmp_info_t *this_thr = __kmp_entry_thread(); 
+         
+        switch (cancel_kind) { 
+        case cancel_parallel: 
+        case cancel_loop: 
+        case cancel_sections: 
+            { 
+                kmp_team_t *this_team = this_thr->th.th_team; 
+                return this_team->t.t_cancel_request == cancel_kind; 
+            } 
+        case cancel_taskgroup: 
+            { 
+                kmp_taskdata_t*  task;  
+                kmp_taskgroup_t* taskgroup; 
+                task = this_thr->th.th_current_task; 
+                taskgroup = task->td_taskgroup; 
+                return taskgroup && taskgroup->cancel_request; 
+            } 
+        } 
+    } 
+ 
+    return 0 /* false */; 
+} 
+ 
+#endif