开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 嵌入式/单片机编程 > 嵌入式Linux > 查看源码
nodemask.h
资源名称：SBC-2410X_kernel.tar.gz　[点击查看]
上传用户：lgb322
上传日期：2013-02-24
资源大小：30529k
文件大小：10k
源码类别：

嵌入式Linux

开发平台：

Unix_Linux

nodemask.h：源码内容
  1. /* $Id$
  2.  *
  3.  * This file is subject to the terms and conditions of the GNU General Public
  4.  * License.  See the file "COPYING" in the main directory of this archive
  5.  * for more details.
  6.  *
  7.  * Copyright (C) 1992 - 1997, 2000 Silicon Graphics, Inc.
  8.  * Copyright (C) 2000 by Colin Ngam
  9.  */
  10. #ifndef _ASM_SN_NODEMASK_H
  11. #define _ASM_SN_NODEMASK_H
  13. #if defined(__KERNEL__) || defined(_KMEMUSER)
  15. #include <linux/config.h>
  17. #if CONFIG_SGI_IP35 || CONFIG_IA64_SGI_SN1 || CONFIG_IA64_GENERIC
  18. #include <asm/sn/sn1/arch.h>    /* needed for MAX_COMPACT_NODES */
  19. #endif
  21. #define CNODEMASK_BOOTED_MASK boot_cnodemask
  22. #define CNODEMASK_BIPW    64
  24. #if !defined(SN0XXL) && !defined(CONFIG_SGI_IP35) && !defined(CONFIG_IA64_SGI_SN1) && !defined(CONFIG_IA64_GENERIC)
  25. /* MAXCPUS 128p (64 nodes) or less */
  27. #define CNODEMASK_SIZE    1
  28. typedef uint64_t cnodemask_t;
  30. #define CNODEMASK_WORD(p,w)     (p)
  31. #define CNODEMASK_SET_WORD(p,w,val)     (p) = val
  32. #define CNODEMASK_CLRALL(p)     (p) = 0
  33. #define CNODEMASK_SETALL(p)     (p) = ~((cnodemask_t)0)
  34. #define CNODEMASK_IS_ZERO(p) ((p) == 0)
  35. #define CNODEMASK_IS_NONZERO(p) ((p) != 0)
  36. #define CNODEMASK_NOTEQ(p, q) ((p) != (q))
  37. #define CNODEMASK_EQ(p, q)      ((p) == (q))
  38. #define CNODEMASK_LSB_ISONE(p)  ((p) & 0x1ULL)
  40. #define CNODEMASK_ZERO()        ((cnodemask_t)0)
  41. #define CNODEMASK_CVTB(bit)     (1ULL << (bit))
  42. #define CNODEMASK_SETB(p, bit) ((p) |= 1ULL << (bit))
  43. #define CNODEMASK_CLRB(p, bit) ((p) &= ~(1ULL << (bit)))
  44. #define CNODEMASK_TSTB(p, bit) ((p) & (1ULL << (bit)))
  46. #define CNODEMASK_SETM(p, q) ((p) |= (q))
  47. #define CNODEMASK_CLRM(p, q) ((p) &= ~(q))
  48. #define CNODEMASK_ANDM(p, q) ((p) &= (q))
  49. #define CNODEMASK_TSTM(p, q) ((p) & (q))
  51. #define CNODEMASK_CPYNOTM(p, q) ((p) = ~(q))
  52. #define CNODEMASK_CPY(p, q)     ((p) = (q))
  53. #define CNODEMASK_ORNOTM(p, q) ((p) |= ~(q))
  54. #define CNODEMASK_SHIFTL(p)     ((p) <<= 1)
  55. #define CNODEMASK_SHIFTR(p)     ((p) >>= 1)
  56. #define CNODEMASK_SHIFTL_PTR(p)     (*(p) <<= 1)
  57. #define CNODEMASK_SHIFTR_PTR(p)     (*(p) >>= 1)
  59. /* Atomically set or clear a particular bit */
  60. #define CNODEMASK_ATOMSET_BIT(p, bit) atomicSetUlong((cnodemask_t *)&(p), (1ULL<<(bit))) 
  61. #define CNODEMASK_ATOMCLR_BIT(p, bit) atomicClearUlong((cnodemask_t *)&(p), (1ULL<<(bit)))
  63. /* Atomically set or clear a collection of bits */
  64. #define CNODEMASK_ATOMSET(p, q)  atomicSetUlong((cnodemask_t *)&(p), q)
  65. #define CNODEMASK_ATOMCLR(p, q)  atomicClearUlong((cnodemask_t *)&(p), q)
  67. /* Atomically set or clear a collection of bits, returning the old value */
  68. #define CNODEMASK_ATOMSET_MASK(__old, p, q) { 
  69. (__old) = atomicSetUlong((cnodemask_t *)&(p), q); 
  70. }
  71. #define CNODEMASK_ATOMCLR_MASK(__old, p, q) { 
  72. (__old) = atomicClearUlong((cnodemask_t *)&(p),q); 
  73. }
  75. #define CNODEMASK_FROM_NUMNODES(n) ((~(cnodemask_t)0)>>(CNODEMASK_BIPW-(n)))
  77. #else  /* SN0XXL || SN1 - MAXCPUS > 128 */
  79. #define CNODEMASK_SIZE    (MAX_COMPACT_NODES / CNODEMASK_BIPW)
  81. typedef struct {
  82.         uint64_t _bits[CNODEMASK_SIZE];
  83. } cnodemask_t;
  85. #define CNODEMASK_WORD(p,w)  
  86. ((w >= 0 && w < CNODEMASK_SIZE) ? (p)._bits[(w)] : 0)
  87. #define CNODEMASK_SET_WORD(p,w,val)  { 
  88. if (w >= 0 && w < CNODEMASK_SIZE) 
  89. (p)._bits[(w)] = val;
  90. }
  92. #define CNODEMASK_CLRALL(p)       {                             
  93.         int i;                                                  
  94.                                                                 
  95.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  96.                 (p)._bits[i] = 0;                               
  97. }
  99. #define CNODEMASK_SETALL(p)       {                             
  100.         int i;                                                  
  101.                                                                 
  102.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  103.                 (p)._bits[i] = ~(0);                            
  104. }
  106. #define CNODEMASK_LSB_ISONE(p)  ((p)._bits[0] & 0x1ULL)
  109. #define CNODEMASK_SETM(p,q)       {                             
  110.         int i;                                                  
  111.                                                                 
  112.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  113.                 (p)._bits[i] |= ((q)._bits[i]);                 
  114. }
  116. #define CNODEMASK_CLRM(p,q)       {                             
  117.         int i;                                                  
  118.                                                                 
  119.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  120.                 (p)._bits[i] &= ~((q)._bits[i]);                
  121. }
  123. #define CNODEMASK_ANDM(p,q)       {                             
  124.         int i;                                                  
  125.                                                                 
  126.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  127.                 (p)._bits[i] &= ((q)._bits[i]);                 
  128. }
  130. #define CNODEMASK_CPY(p, q)  {
  131.         int i;                                                  
  132.                                                                 
  133.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  134.                 (p)._bits[i] = (q)._bits[i];                 
  135. }
  137. #define CNODEMASK_CPYNOTM(p,q)    {                             
  138.         int i;                                                  
  139.                                                                 
  140.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  141.                 (p)._bits[i] = ~((q)._bits[i]);                 
  142. }
  144. #define CNODEMASK_ORNOTM(p,q)     {                             
  145.         int i;                                                  
  146.                                                                 
  147.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)                  
  148.                 (p)._bits[i] |= ~((q)._bits[i]);                
  149. }
  151. #define CNODEMASK_INDEX(bit)      ((bit) >> 6)
  152. #define CNODEMASK_SHFT(bit)       ((bit) & 0x3f)
  155. #define CNODEMASK_SETB(p, bit)  
  156. (p)._bits[CNODEMASK_INDEX(bit)] |= (1ULL << CNODEMASK_SHFT(bit))
  159. #define CNODEMASK_CLRB(p, bit)
  160. (p)._bits[CNODEMASK_INDEX(bit)] &= ~(1ULL << CNODEMASK_SHFT(bit)) 
  163. #define CNODEMASK_TSTB(p, bit)
  164. ((p)._bits[CNODEMASK_INDEX(bit)] & (1ULL << CNODEMASK_SHFT(bit))) 
  166. /** Probably should add atomic update for entire cnodemask_t struct **/
  168. /* Atomically set or clear a particular bit */
  169. #define CNODEMASK_ATOMSET_BIT(p, bit) 
  170.         (atomicSetUlong((unsigned long *)&(p)._bits[CNODEMASK_INDEX(bit)], (1ULL << CNODEMASK_SHFT(bit))));
  171. #define CNODEMASK_ATOMCLR_BIT(__old, p, bit) 
  172.         (atomicClearUlong((unsigned long *)&(p)._bits[CNODEMASK_INDEX(bit)], (1ULL << CNODEMASK_SHFT(bit))));
  174. /* Atomically set or clear a collection of bits */
  175. #define CNODEMASK_ATOMSET(p, q) { 
  176.         int i;
  178.         for (i = 0 ; i < CNODEMASK_SIZE ; i++) { 
  179.       atomicSetUlong((unsigned long *)&(p)._bits[i], (q)._bits[i]);  
  180.         }
  181. }
  182. #define CNODEMASK_ATOMCLR(p, q) { 
  183.         int i;
  184.                         
  185.         for (i = 0 ; i < CNODEMASK_SIZE ; i++) {
  186.       atomicClearUlong((unsigned long *)&(p)._bits[i], (q)._bits[i]); 
  187.         }
  188. }
  190. /* Atomically set or clear a collection of bits, returning the old value */
  191. #define CNODEMASK_ATOMSET_MASK(__old, p, q)  { 
  192.         int i;
  194.         for (i = 0 ; i < CNODEMASK_SIZE ; i++) { 
  195.            (__old)._bits[i] =  
  196.       atomicSetUlong((unsigned long *)&(p)._bits[i], (q)._bits[i]);  
  197.         }
  198. }
  199. #define CNODEMASK_ATOMCLR_MASK(__old, p, q) {
  200.         int i;
  201.                         
  202.         for (i = 0 ; i < CNODEMASK_SIZE ; i++) {
  203.            (__old)._bits[i] =
  204.       atomicClearUlong((unsigned long *)&(p)._bits[i], (q)._bits[i]); 
  205.         }
  206. }
  208. __inline static cnodemask_t CNODEMASK_CVTB(int bit) 
  209. {
  210. cnodemask_t __tmp;
  211. CNODEMASK_CLRALL(__tmp);
  212. CNODEMASK_SETB(__tmp,bit);
  213. return(__tmp);
  214. }
  217. __inline static cnodemask_t CNODEMASK_ZERO(void)
  218. {
  219. cnodemask_t __tmp;
  220. CNODEMASK_CLRALL(__tmp);
  221. return(__tmp);
  222. }
  224. __inline static int CNODEMASK_IS_ZERO (cnodemask_t p)
  225. {
  226.         int i;
  228.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)
  229.                 if (p._bits[i] != 0)
  230.                         return 0;
  231.         return 1;
  232. }
  234. __inline static int CNODEMASK_IS_NONZERO (cnodemask_t p)
  235. {
  236.         int i;
  238.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)
  239.                 if (p._bits[i] != 0)
  240.                         return 1;
  241.         return 0;
  242. }
  244. __inline static int CNODEMASK_NOTEQ (cnodemask_t p, cnodemask_t q)
  245. {
  246.         int i;
  248.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)
  249.                 if (p._bits[i] != q._bits[i])
  250.                         return 1;
  251.         return 0;
  252. }
  254. __inline static int CNODEMASK_EQ (cnodemask_t p, cnodemask_t q)
  255. {
  256.         int i;
  258.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)
  259.                 if (p._bits[i] != q._bits[i])
  260.                         return 0;
  261.         return 1;
  262. }
  265. __inline static int CNODEMASK_TSTM (cnodemask_t p, cnodemask_t q)
  266. {
  267.         int i;
  269.         for (i = 0 ; i < CNODEMASK_SIZE ; i++)
  270.                 if (p._bits[i] & q._bits[i])
  271.                         return 1;
  272.         return 0;
  273. }
  275. __inline static void CNODEMASK_SHIFTL_PTR (cnodemask_t *p)
  276. {
  277.         int i;
  278.         uint64_t upper;
  280.         /*
  281.          * shift words starting with the last word
  282.          * of the vector and work backward to the first
  283.          * word updating the low order bits with the
  284.          * high order bit of the prev word.
  285.          */
  286.         for (i=(CNODEMASK_SIZE-1); i > 0; --i) {
  287.    upper = (p->_bits[i-1] & (1ULL<<(CNODEMASK_BIPW-1))) ? 1 : 0;
  288.            p->_bits[i] <<= 1;
  289.            p->_bits[i] |= upper;
  290.         }
  291.         p->_bits[i] <<= 1;
  292. }
  294. __inline static void CNODEMASK_SHIFTR_PTR (cnodemask_t *p)
  295. {
  296.         int i;
  297.         uint64_t lower;
  299.         /*
  300.          * shift words starting with the first word
  301.          * of the vector and work forward to the last
  302.          * word updating the high order bit with the
  303.          * low order bit of the next word.
  304.          */
  305.         for (i=0; i < (CNODEMASK_SIZE-2); ++i) {
  306.    lower = (p->_bits[i+1] & (0x1)) ? 1 : 0;
  307.            p->_bits[i] >>= 1;
  308.            p->_bits[i] |= (lower<<((CNODEMASK_BIPW-1)));
  309.         }
  310.         p->_bits[i] >>= 1;
  311. }
  313. __inline static cnodemask_t CNODEMASK_FROM_NUMNODES(int n)
  314. {
  315. cnodemask_t __tmp;
  316. int i;
  317. CNODEMASK_CLRALL(__tmp);
  318. for (i=0; i<n; i++) {
  319. CNODEMASK_SETB(__tmp, i);
  320. }
  321. return(__tmp);
  322. }
  324. #endif /* SN0XXL || SN1 */
  326. extern cnodemask_t boot_cnodemask;
  328. #endif /* __KERNEL__ || _KMEMUSER */
  330. #endif /* _ASM_SN_NODEMASK_H */