Implement sched_getcpu() (XCC)
[akaros.git] / tools / compilers / gcc-glibc / glibc-2.19-akaros / sysdeps / akaros / bits / sched.h
1 /* Definitions of constants and data structure for POSIX 1003.1b-1993
2    scheduling interface.
3    Copyright (C) 1996-2014 Free Software Foundation, Inc.
4    This file is part of the GNU C Library.
5
6    The GNU C Library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    The GNU C Library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with the GNU C Library; if not, see
18    <http://www.gnu.org/licenses/>.  */
19
20 /* NOTE: This is the glibc 'bits/sched.h' with Akaros definitions
21    appended to the end. */
22
23 #ifndef __need_schedparam
24
25 #ifndef _SCHED_H
26 # error "Never include <bits/sched.h> directly; use <sched.h> instead."
27 #endif
28
29
30 /* Scheduling algorithms.  */
31 #define SCHED_OTHER     0
32 #define SCHED_FIFO      1
33 #define SCHED_RR        2
34
35 /* Data structure to describe a process' schedulability.  */
36 struct sched_param
37 {
38   int __sched_priority;
39 };
40
41 #endif  /* need schedparam */
42
43 #if !defined __defined_schedparam \
44     && (defined __need_schedparam || defined _SCHED_H)
45 # define __defined_schedparam   1
46 /* Data structure to describe a process' schedulability.  */
47 struct __sched_param
48   {
49     int __sched_priority;
50   };
51 # undef __need_schedparam
52 #endif
53
54
55 #if defined _SCHED_H && !defined __cpu_set_t_defined
56 # define __cpu_set_t_defined
57 /* Size definition for CPU sets.  */
58 # define __CPU_SETSIZE  1024
59 # define __NCPUBITS     (8 * sizeof (__cpu_mask))
60
61 /* Type for array elements in 'cpu_set_t'.  */
62 typedef unsigned long int __cpu_mask;
63
64 /* Basic access functions.  */
65 # define __CPUELT(cpu)  ((cpu) / __NCPUBITS)
66 # define __CPUMASK(cpu) ((__cpu_mask) 1 << ((cpu) % __NCPUBITS))
67
68 /* Data structure to describe CPU mask.  */
69 typedef struct
70 {
71   __cpu_mask __bits[__CPU_SETSIZE / __NCPUBITS];
72 } cpu_set_t;
73
74 /* Access functions for CPU masks.  */
75 # if __GNUC_PREREQ (2, 91)
76 #  define __CPU_ZERO_S(setsize, cpusetp) \
77   do __builtin_memset (cpusetp, '\0', setsize); while (0)
78 # else
79 #  define __CPU_ZERO_S(setsize, cpusetp) \
80   do {                                                                        \
81     size_t __i;                                                               \
82     size_t __imax = (setsize) / sizeof (__cpu_mask);                          \
83     __cpu_mask *__bits = (cpusetp)->__bits;                                   \
84     for (__i = 0; __i < __imax; ++__i)                                        \
85       __bits[__i] = 0;                                                        \
86   } while (0)
87 # endif
88 # define __CPU_SET_S(cpu, setsize, cpusetp) \
89   (__extension__                                                              \
90    ({ size_t __cpu = (cpu);                                                   \
91       __cpu < 8 * (setsize)                                                   \
92       ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]               \
93          |= __CPUMASK (__cpu))                                                \
94       : 0; }))
95 # define __CPU_CLR_S(cpu, setsize, cpusetp) \
96   (__extension__                                                              \
97    ({ size_t __cpu = (cpu);                                                   \
98       __cpu < 8 * (setsize)                                                   \
99       ? (((__cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]               \
100          &= ~__CPUMASK (__cpu))                                               \
101       : 0; }))
102 # define __CPU_ISSET_S(cpu, setsize, cpusetp) \
103   (__extension__                                                              \
104    ({ size_t __cpu = (cpu);                                                   \
105       __cpu < 8 * (setsize)                                                   \
106       ? ((((const __cpu_mask *) ((cpusetp)->__bits))[__CPUELT (__cpu)]      \
107           & __CPUMASK (__cpu))) != 0                                          \
108       : 0; }))
109
110 # define __CPU_COUNT_S(setsize, cpusetp) \
111   __sched_cpucount (setsize, cpusetp)
112
113 # if __GNUC_PREREQ (2, 91)
114 #  define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \
115   (__builtin_memcmp (cpusetp1, cpusetp2, setsize) == 0)
116 # else
117 #  define __CPU_EQUAL_S(setsize, cpusetp1, cpusetp2) \
118   (__extension__                                                              \
119    ({ const __cpu_mask *__arr1 = (cpusetp1)->__bits;                          \
120       const __cpu_mask *__arr2 = (cpusetp2)->__bits;                          \
121       size_t __imax = (setsize) / sizeof (__cpu_mask);                        \
122       size_t __i;                                                             \
123       for (__i = 0; __i < __imax; ++__i)                                      \
124         if (__arr1[__i] != __arr2[__i])                                       \
125           break;                                                              \
126       __i == __imax; }))
127 # endif
128
129 # define __CPU_OP_S(setsize, destset, srcset1, srcset2, op) \
130   (__extension__                                                              \
131    ({ cpu_set_t *__dest = (destset);                                          \
132       const __cpu_mask *__arr1 = (srcset1)->__bits;                           \
133       const __cpu_mask *__arr2 = (srcset2)->__bits;                           \
134       size_t __imax = (setsize) / sizeof (__cpu_mask);                        \
135       size_t __i;                                                             \
136       for (__i = 0; __i < __imax; ++__i)                                      \
137         ((__cpu_mask *) __dest->__bits)[__i] = __arr1[__i] op __arr2[__i];    \
138       __dest; }))
139
140 # define __CPU_ALLOC_SIZE(count) \
141   ((((count) + __NCPUBITS - 1) / __NCPUBITS) * sizeof (__cpu_mask))
142 # define __CPU_ALLOC(count) __sched_cpualloc (count)
143 # define __CPU_FREE(cpuset) __sched_cpufree (cpuset)
144
145 __BEGIN_DECLS
146
147 extern int __sched_cpucount (size_t __setsize, const cpu_set_t *__setp)
148      __THROW;
149 extern cpu_set_t *__sched_cpualloc (size_t __count) __THROW __wur;
150 extern void __sched_cpufree (cpu_set_t *__set) __THROW;
151
152 /* AKAROS AKAROS AKAROS */
153 extern int sched_getcpu(void);
154 /* AKAROS AKAROS AKAROS */
155
156 __END_DECLS
157
158 #endif