p99_iterator.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 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_ITERATOR_H
#define P99_ITERATOR_H
 
#include "p99_futex.h"
 
P99_DECLARE_STRUCT(p99_iterator);
 
struct p99_iterator {
  unsigned p00_act;
  p99_futex p00_seen;
};
 
P99_DEFARG_DOCU(p99_iterator_init)
p99_inline
p99_iterator* p99_iterator_init(p99_iterator* p00_i) {
  if (p00_i) {
    p00_i->p00_act = 0;
    p99_futex_init(&p00_i->p00_seen, 0);
  }
  return p00_i;
}
 
p99_inline
void p99_iterator_destroy(p99_iterator* p00_i) {
  if (p00_i) {
    p99_futex_destroy(&p00_i->p00_seen);
  }
}
 
P99_DEFARG_DOCU(p99_iterator_next)
P00_FUTEX_INLINE(p99_iterator_next)
unsigned p99_iterator_next(p99_iterator volatile* p00_i) {
  register unsigned const p00_act = p00_i->p00_act;
  P99_FUTEX_COMPARE_EXCHANGE(&p00_i->p00_seen, p00_seen,
                             /* wait for more events than we have
                                already processed */
                             (p00_act < p00_seen),
                             /* never update */
                             p00_seen,
                             /* never wakeup others */
                             0u, 0u);
  p00_i->p00_act = p00_act + 1;
  return p00_act;
}
 
P99_DEFARG_DOCU(p99_iterator_signal)
p99_inline
unsigned p99_iterator_signal(p99_iterator volatile* p00_i) {
  return p99_futex_add(&p00_i->p00_seen, 1u, 0u, UINT_MAX, 0u, P99_FUTEX_MAX_WAITERS);
}
 
 
P99_DECLARE_STRUCT(p99_event);
 
struct p99_event {
  p99_iterator p00_it;
  unsigned p00_n;
  void ** p00_event;
};
 
P99_DEFARG_DOCU(p99_event_init)
p99_inline
p99_event* p99_event_init(p99_event* p00_e, unsigned p00_n) {
  if (p00_e) {
    (*p00_e) = (p99_event) {
      .p00_n = p00_n,
      .p00_event = P99_MEMZERO(void_ptr, P99_MALLOC(void_ptr[p00_n]), p00_n),
    };
    p99_iterator_init(&p00_e->p00_it);
  }
  return p00_e;
}
 
p99_inline
void p99_event_destroy(p99_event* p00_e) {
  if (p00_e) {
    free(p00_e->p00_event);
    p99_iterator_destroy(&p00_e->p00_it);
  }
}
 
P99_DEFARG_DOCU(p99_event_next)
P00_FUTEX_INLINE(p99_event_next)
void* p99_event_next(p99_event volatile* p00_e) {
  P99_FPRINTF(stderr, "next event on %s\n", (void*)p00_e);
  unsigned p00_pos = p99_iterator_next(&p00_e->p00_it);
  void* p00_ret = 0;
  if (p00_pos < p00_e->p00_n)
    while (!(p00_ret = p00_e->p00_event[p00_pos]));
  P99_FPRINTF(stderr, "next event on %s, returns %s pos %s\n", (void*)p00_e, p00_ret, p00_pos);
  return p00_ret;
}
 
P99_DEFARG_DOCU(p99_event_signal)
p99_inline
void p99_event_signal(p99_event volatile* p00_e, void * p00_w) {
  if (p00_e) {
    unsigned p00_ret = p99_iterator_signal(&p00_e->p00_it);
    p00_e->p00_event[p00_ret] = p00_w;
  }
}
 
 
#endif