p99_count.h

Go to the documentation of this file.

/* This may look like nonsense, but it really is -*- mode: C; coding: utf-8 -*- */
/*                                                                              */
/* Except for parts copied from previous work and as explicitly stated below,   */
/* the author and copyright holder for this work is                             */
/* (C) copyright  2012, 2016 Jens Gustedt, INRIA, France                        */
/*                                                                              */
/* This file is free software; it is part of the P99 project.                   */
/*                                                                              */
/* Licensed under the Apache License, Version 2.0 (the "License");              */
/* you may not use this file except in compliance with the License.             */
/* You may obtain a copy of the License at                                      */
/*                                                                              */
/*     http://www.apache.org/licenses/LICENSE-2.0                               */
/*                                                                              */
/* Unless required by applicable law or agreed to in writing, software          */
/* distributed under the License is distributed on an "AS IS" BASIS,            */
/* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.     */
/* See the License for the specific language governing permissions and          */
/* limitations under the License.                                               */
/*                                                                              */
#ifndef P99_COUNT_H
#define P99_COUNT_H
 
#include "p99_futex.h"
 
#ifdef P00_DOXYGEN
struct p99_count {};
#else
typedef p99_futex p99_count;
#endif
 
# define P99_COUNT_INITIALIZER P99_FUTEX_INITIALIZER
 
P99_DEFARG_DOCU(p99_count_init)
p99_inline
p99_count* p99_count_init(p99_count* p00_c, unsigned p00_v) {
  return p99_futex_init(p00_c, p00_v);
}
 
#define p99_count_init(...) P99_CALL_DEFARG(p99_count_init, 2, __VA_ARGS__)
#define p99_count_init_defarg_1() 0U
 
p99_inline
void p99_count_destroy(p99_count* p00_c) {
  p99_futex_destroy(p00_c);
}
 
P99_BLOCK_DOCUMENT
#define P99_ACCOUNT(COUNT)                                              \
P00_BLK_DECL(p99_count*, p00Mcount, &(COUNT))                           \
P99_PROTECTED_BLOCK(p99_count_inc(p00Mcount), p99_count_dec(p00Mcount))
 
P99_DEFARG_DOCU(p99_count_inc)
p99_inline unsigned p99_count_inc(p99_count volatile* p00_c, unsigned p00_hm) {
  return p99_futex_add(p00_c, p00_hm, 0U, 0U, 0U, 0U);
}
 
#define p99_count_inc(...) P99_CALL_DEFARG(p99_count_inc, 2, __VA_ARGS__)
#define p99_count_inc_defarg_1() (1U)
 
P99_DEFARG_DOCU(p99_count_inc_conditionally)
P00_FUTEX_INLINE(p99_count_inc_conditionally)
unsigned p99_count_inc_conditionally(p99_count volatile* p00_c, unsigned p00_hm) {
  unsigned p00_ret = 0;
  P99_FUTEX_COMPARE_EXCHANGE(p00_c, p00_act,
                             /* never wait */
                             true,
                             /* only do something if positive */
                             (!p00_act ? 0U : p00_act + p00_hm),
                             /* capture the state for return, but
                                never wakeup and waiters */
                             ((p00_ret = p00_act), 0), 0);
  return p00_ret;
}
 
#define p99_count_inc_conditionally(...) P99_CALL_DEFARG(p99_count_inc_conditionally, 2, __VA_ARGS__)
#define p99_count_inc_conditionally_defarg_1() (1U)
 
p99_inline unsigned p99_count_value(p99_count volatile* p00_c) {
  return p99_futex_load(p00_c);
}
 
 
P99_DEFARG_DOCU(p99_count_dec)
p99_inline
unsigned p99_count_dec(p99_count volatile* p00_c, unsigned p00_hm) {
  unsigned ret = p99_futex_add(p00_c, -(signed)p00_hm, 0U, 1U, 0U, P99_FUTEX_MAX_WAITERS);
  return ret - p00_hm;
}
 
#define p99_count_dec(...) P99_CALL_DEFARG(p99_count_dec, 2, __VA_ARGS__)
#define p99_count_dec_defarg_1() (1U)
 
P00_FUTEX_INLINE(p99_count_wait)
void p99_count_wait(p99_count volatile* p00_c) {
  P99_FUTEX_COMPARE_EXCHANGE(p00_c, p00_act, !p00_act, p00_act, 0U, 0U);
}
 
#endif