← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ctfutils/trusty-proposed

« back to all changes in this revision

Viewing changes to cddl/contrib/opensolaris/tools/ctf/cvt/barrier.c

  • Committer: Package Import Robot
  • Author(s): Robert Millan
  • Date: 2013-11-09 17:07:06 UTC
  • Revision ID: package-import@ubuntu.com-20131109170706-kacr6nvpkbhxsk81
Tags: upstream-9.2
Import upstream version 9.2

Show diffs side-by-side

added added

removed removed

Lines of Context:
cddl/contrib/opensolaris/tools/ctf/cvt/barrier.c
 
1
/*
 
2
 * CDDL HEADER START
 
3
 *
 
4
 * The contents of this file are subject to the terms of the
 
5
 * Common Development and Distribution License, Version 1.0 only
 
6
 * (the "License").  You may not use this file except in compliance
 
7
 * with the License.
 
8
 *
 
9
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 
10
 * or http://www.opensolaris.org/os/licensing.
 
11
 * See the License for the specific language governing permissions
 
12
 * and limitations under the License.
 
13
 *
 
14
 * When distributing Covered Code, include this CDDL HEADER in each
 
15
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 
16
 * If applicable, add the following below this CDDL HEADER, with the
 
17
 * fields enclosed by brackets "[]" replaced with your own identifying
 
18
 * information: Portions Copyright [yyyy] [name of copyright owner]
 
19
 *
 
20
 * CDDL HEADER END
 
21
 */
 
22
/*
 
23
 * Copyright 2002 Sun Microsystems, Inc.  All rights reserved.
 
24
 * Use is subject to license terms.
 
25
 */
 
26
 
 
27
#pragma ident   "%Z%%M% %I%     %E% SMI"
 
28
 
 
29
/*
 
30
 * This file implements a barrier, a synchronization primitive designed to allow
 
31
 * threads to wait for each other at given points.  Barriers are initialized
 
32
 * with a given number of threads, n, using barrier_init().  When a thread calls
 
33
 * barrier_wait(), that thread blocks until n - 1 other threads reach the
 
34
 * barrier_wait() call using the same barrier_t.  When n threads have reached
 
35
 * the barrier, they are all awakened and sent on their way.  One of the threads
 
36
 * returns from barrier_wait() with a return code of 1; the remaining threads
 
37
 * get a return code of 0.
 
38
 */
 
39
 
 
40
#include <pthread.h>
 
41
#if defined(sun)
 
42
#include <synch.h>
 
43
#endif
 
44
#include <stdio.h>
 
45
 
 
46
#include "barrier.h"
 
47
 
 
48
void
 
49
barrier_init(barrier_t *bar, int nthreads)
 
50
{
 
51
        pthread_mutex_init(&bar->bar_lock, NULL);
 
52
#if defined(sun)
 
53
        sema_init(&bar->bar_sem, 0, USYNC_THREAD, NULL);
 
54
#else
 
55
        sem_init(&bar->bar_sem, 0, 0);
 
56
#endif
 
57
 
 
58
        bar->bar_numin = 0;
 
59
        bar->bar_nthr = nthreads;
 
60
}
 
61
 
 
62
int
 
63
barrier_wait(barrier_t *bar)
 
64
{
 
65
        pthread_mutex_lock(&bar->bar_lock);
 
66
 
 
67
        if (++bar->bar_numin < bar->bar_nthr) {
 
68
                pthread_mutex_unlock(&bar->bar_lock);
 
69
#if defined(sun)
 
70
                sema_wait(&bar->bar_sem);
 
71
#else
 
72
                sem_wait(&bar->bar_sem);
 
73
#endif
 
74
 
 
75
                return (0);
 
76
 
 
77
        } else {
 
78
                int i;
 
79
 
 
80
                /* reset for next use */
 
81
                bar->bar_numin = 0;
 
82
                for (i = 1; i < bar->bar_nthr; i++)
 
83
#if defined(sun)
 
84
                        sema_post(&bar->bar_sem);
 
85
#else
 
86
                        sem_post(&bar->bar_sem);
 
87
#endif
 
88
                pthread_mutex_unlock(&bar->bar_lock);
 
89
 
 
90
                return (1);
 
91
        }
 
92
}