URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [tags/] [gnu-src/] [gcc-4.5.1/] [gcc-4.5.1-or32-1.0rc1/] [libgomp/] [config/] [linux/] [bar.c] - Rev 273
Go to most recent revision | Compare with Previous | Blame | View Log
/* Copyright (C) 2005, 2008, 2009 Free Software Foundation, Inc. Contributed by Richard Henderson <rth@redhat.com>. This file is part of the GNU OpenMP Library (libgomp). Libgomp is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. Libgomp is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. Under Section 7 of GPL version 3, you are granted additional permissions described in the GCC Runtime Library Exception, version 3.1, as published by the Free Software Foundation. You should have received a copy of the GNU General Public License and a copy of the GCC Runtime Library Exception along with this program; see the files COPYING3 and COPYING.RUNTIME respectively. If not, see <http://www.gnu.org/licenses/>. */ /* This is a Linux specific implementation of a barrier synchronization mechanism for libgomp. This type is private to the library. This implementation uses atomic instructions and the futex syscall. */ #include <limits.h> #include "wait.h" void gomp_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state) { if (__builtin_expect ((state & 1) != 0, 0)) { /* Next time we'll be awaiting TOTAL threads again. */ bar->awaited = bar->total; atomic_write_barrier (); bar->generation += 4; futex_wake ((int *) &bar->generation, INT_MAX); } else { unsigned int generation = state; do do_wait ((int *) &bar->generation, generation); while (bar->generation == generation); } } void gomp_barrier_wait (gomp_barrier_t *bar) { gomp_barrier_wait_end (bar, gomp_barrier_wait_start (bar)); } /* Like gomp_barrier_wait, except that if the encountering thread is not the last one to hit the barrier, it returns immediately. The intended usage is that a thread which intends to gomp_barrier_destroy this barrier calls gomp_barrier_wait, while all other threads call gomp_barrier_wait_last. When gomp_barrier_wait returns, the barrier can be safely destroyed. */ void gomp_barrier_wait_last (gomp_barrier_t *bar) { gomp_barrier_state_t state = gomp_barrier_wait_start (bar); if (state & 1) gomp_barrier_wait_end (bar, state); } void gomp_team_barrier_wake (gomp_barrier_t *bar, int count) { futex_wake ((int *) &bar->generation, count == 0 ? INT_MAX : count); } void gomp_team_barrier_wait_end (gomp_barrier_t *bar, gomp_barrier_state_t state) { unsigned int generation; if (__builtin_expect ((state & 1) != 0, 0)) { /* Next time we'll be awaiting TOTAL threads again. */ struct gomp_thread *thr = gomp_thread (); struct gomp_team *team = thr->ts.team; bar->awaited = bar->total; atomic_write_barrier (); if (__builtin_expect (team->task_count, 0)) { gomp_barrier_handle_tasks (state); state &= ~1; } else { bar->generation = state + 3; futex_wake ((int *) &bar->generation, INT_MAX); return; } } generation = state; do { do_wait ((int *) &bar->generation, generation); if (__builtin_expect (bar->generation & 1, 0)) gomp_barrier_handle_tasks (state); if ((bar->generation & 2)) generation |= 2; } while (bar->generation != state + 4); } void gomp_team_barrier_wait (gomp_barrier_t *bar) { gomp_team_barrier_wait_end (bar, gomp_barrier_wait_start (bar)); }
Go to most recent revision | Compare with Previous | Blame | View Log