__timeout.h

 
/*
 * (c) 2008-2009 Adam Lackorzynski <adam@os.inf.tu-dresden.de>,
 *               Alexander Warg <warg@os.inf.tu-dresden.de>,
 *               Torsten Frenzel <frenzel@os.inf.tu-dresden.de>
 *     economic rights: Technische Universität Dresden (Germany)
 *
 * This file is part of TUD:OS and distributed under the terms of the
 * GNU General Public License 2.
 * Please see the COPYING-GPL-2 file for details.
 *
 * As a special exception, you may use this file as part of a free software
 * library without restriction.  Specifically, if other files instantiate
 * templates or use macros or inline functions from this file, or you compile
 * this file and link it with other files to produce an executable, this
 * file does not by itself cause the resulting executable to be covered by
 * the GNU General Public License.  This exception does not however
 * invalidate any other reasons why the executable file might be covered by
 * the GNU General Public License.
 */
#ifndef L4_SYS_TIMEOUT_H__
#define L4_SYS_TIMEOUT_H__
 
#include <l4/sys/l4int.h>
#include <l4/sys/compiler.h>
 
typedef struct l4_timeout_s {
  l4_uint16_t t;                           
} __attribute__((packed)) l4_timeout_s;
 
 
typedef union l4_timeout_t
{
  l4_uint32_t raw;                 
  struct
  {
#ifdef __BIG_ENDIAN__
    l4_timeout_s snd;              
    l4_timeout_s rcv;              
#else
    l4_timeout_s rcv;              
    l4_timeout_s snd;              
#endif
  } p;                             
} l4_timeout_t;
 
 
#define L4_IPC_TIMEOUT_0 ((l4_timeout_s){0x0400})           
#define L4_IPC_TIMEOUT_NEVER ((l4_timeout_s){0})            
#define L4_IPC_NEVER_INITIALIZER {0}                        
#define L4_IPC_NEVER ((l4_timeout_t){0})                    
#define L4_IPC_RECV_TIMEOUT_0 ((l4_timeout_t){0x00000400})  
#define L4_IPC_SEND_TIMEOUT_0 ((l4_timeout_t){0x04000000})  
#define L4_IPC_BOTH_TIMEOUT_0 ((l4_timeout_t){0x04000400})  
#define L4_TIMEOUT_US_NEVER (~0ULL)
 
#define L4_TIMEOUT_US_MAX   ((1ULL << 41) - 1)
 
L4_CONSTEXPR L4_INLINE
l4_timeout_s l4_timeout_rel(unsigned man, unsigned exp) L4_NOTHROW;
 
 
L4_CONSTEXPR L4_INLINE
l4_timeout_t l4_ipc_timeout(unsigned snd_man, unsigned snd_exp,
                            unsigned rcv_man, unsigned rcv_exp) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
l4_timeout_t l4_timeout(l4_timeout_s snd, l4_timeout_s rcv) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
void l4_snd_timeout(l4_timeout_s snd, l4_timeout_t *to) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
void l4_rcv_timeout(l4_timeout_s rcv, l4_timeout_t *to) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
l4_kernel_clock_t l4_timeout_rel_get(l4_timeout_s to) L4_NOTHROW;
 
 
L4_CONSTEXPR L4_INLINE
unsigned l4_timeout_is_absolute(l4_timeout_s to) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
l4_kernel_clock_t l4_timeout_get(l4_kernel_clock_t cur, l4_timeout_s to) L4_NOTHROW;
 
L4_CONSTEXPR L4_INLINE
l4_timeout_s l4_timeout_from_us(l4_uint64_t us) L4_NOTHROW;
 
/*
 * Implementation
 */
 
L4_CONSTEXPR L4_INLINE
l4_timeout_t l4_ipc_timeout(unsigned snd_man, unsigned snd_exp,
                            unsigned rcv_man, unsigned rcv_exp) L4_NOTHROW
{
  l4_uint16_t snd = (snd_man & 0x3ff) | ((snd_exp << 10) & 0x7c00);
  l4_uint16_t rcv = (rcv_man & 0x3ff) | ((rcv_exp << 10) & 0x7c00);
  return l4_timeout((l4_timeout_s){snd}, (l4_timeout_s){rcv});
}
 
 
L4_CONSTEXPR L4_INLINE
l4_timeout_t l4_timeout(l4_timeout_s snd, l4_timeout_s rcv) L4_NOTHROW
{
  return (l4_timeout_t){ ((l4_uint32_t){snd.t} << 16) | rcv.t };
}
 
 
L4_CONSTEXPR L4_INLINE
void l4_snd_timeout(l4_timeout_s snd, l4_timeout_t *to) L4_NOTHROW
{
  to->p.snd = snd;
}
 
 
L4_CONSTEXPR L4_INLINE
void l4_rcv_timeout(l4_timeout_s rcv, l4_timeout_t *to) L4_NOTHROW
{
  to->p.rcv = rcv;
}
 
 
L4_CONSTEXPR L4_INLINE
l4_timeout_s l4_timeout_rel(unsigned man, unsigned exp) L4_NOTHROW
{
  return (l4_timeout_s){(l4_uint16_t)((man & 0x3ff) | ((exp << 10) & 0x7c00))};
}
 
 
L4_CONSTEXPR L4_INLINE
l4_kernel_clock_t l4_timeout_rel_get(l4_timeout_s to) L4_NOTHROW
{
  if (to.t == 0)
    return ~0ULL;
  return (l4_kernel_clock_t)(to.t & 0x3ff) << ((to.t >> 10) & 0x1f);
}
 
 
L4_CONSTEXPR L4_INLINE
unsigned l4_timeout_is_absolute(l4_timeout_s to) L4_NOTHROW
{
  return to.t & 0x8000;
}
 
 
L4_CONSTEXPR L4_INLINE
l4_kernel_clock_t l4_timeout_get(l4_kernel_clock_t cur, l4_timeout_s to) L4_NOTHROW
{
  if (l4_timeout_is_absolute(to))
    return 0; /* We cannot retrieve the value ... */
  else
    return cur + l4_timeout_rel_get(to);
}
 
L4_CONSTEXPR L4_INLINE
l4_timeout_s l4_timeout_from_us(l4_uint64_t us) L4_NOTHROW
{
  if (us == 0)
    return L4_IPC_TIMEOUT_0;
  else if (us == L4_TIMEOUT_US_NEVER || us > L4_TIMEOUT_US_MAX)
    return L4_IPC_TIMEOUT_NEVER;
  else
    {
      /* Here it is certain that at least one bit in 'us' is set. */
 
      l4_uint16_t m = 0; // initialization required by constexpr, optimized away
      l4_uint16_t v = 0; // initialization required by constexpr, optimized away
      int e = (63 - __builtin_clzll(us)) - 9;
      if (e < 0)
        e = 0;
 
      /* Here it is certain that '0 <= e <= 31' and '1 <= 2^e <= 2^31':
       * L4_TIMEOUT_US_MAX = 2^41-1 = 0x000001ffffffffff => e = 31.
       * Note: 2^41-1 (0x000001ffffffffff) > 1023*2^31 (0x00001ff800000000). */
 
      m = us >> e;
 
      /* Here it is certain that '1 <= m <= 1023. Consider the following cases:
       *  o    1 <= us <= 1023: e = 0; 2^e = 1;   1 <= us/1 <= 1023
       *  o 1024 <= us <= 2047: e = 1; 2^e = 2; 512 <= us/2 <= 1023
       *  o 2048 <= us <= 4095: e = 2; 2^e = 4; 512 <= us/4 <= 1023
       *  ...
       *  o 2^31 <= us <= 2^32-1: e = 22;       512 <= us/2^22 <= 1023
       *  o 2^40 <= us <= 2^41-1: e = 31;       512 <= us/2^31 <= 1023
       *
       * Dividing by (1<<e) ensures that for all us < 2^41: m < 2^10.
       *
       * Maximum possible timeout using this format: L4_TIMEOUT_US_MAX = 2^41-1:
       *  e = 31, m = 1023 => 2'196'875'771'904 us = 610h 14m 35s.
       */
 
      /* Without introducing 'v' we had to type-cast the expression to
       * l4_uint16_t. This cannot be avoided by declaring m and e_pow_10 as
       * l4_uint16_t due to C++ integer promotion. */
      v = (e << 10) | m;
      return (l4_timeout_s){v};
    }
}
 
#endif