Fix cpu_set_t

- extend CPU_SETSIZE for LP64
- fix CPU_(AND|OR|XOR) macros
- fix CPU_OP_S macro
- fix __sched_cpucount
- tidy up the code

Change-Id: I741afff4d0c473e8a1ee6b4141981dc24467e0d4

tests/sched_test.cpp

@@ -50,3 +50,207 @@ TEST(sched, clone) {
   GTEST_LOG_(INFO) << "This test does nothing.\n";
 }
 #endif
+
+TEST(sched, cpu_set) {
+  cpu_set_t set;
+
+  CPU_ZERO(&set);
+  CPU_SET(0, &set);
+  CPU_SET(17, &set);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 0 || i == 17, CPU_ISSET(i, &set));
+  }
+
+  // We should fail silently if we try to set/test outside the range.
+  CPU_SET(CPU_SETSIZE, &set);
+  ASSERT_FALSE(CPU_ISSET(CPU_SETSIZE, &set));
+}
+
+TEST(sched, cpu_count) {
+  cpu_set_t set;
+
+  CPU_ZERO(&set);
+  ASSERT_EQ(0, CPU_COUNT(&set));
+  CPU_SET(2, &set);
+  CPU_SET(10, &set);
+  ASSERT_EQ(2, CPU_COUNT(&set));
+  CPU_CLR(10, &set);
+  ASSERT_EQ(1, CPU_COUNT(&set));
+}
+
+TEST(sched, cpu_zero) {
+  cpu_set_t set;
+
+  CPU_ZERO(&set);
+  ASSERT_EQ(0, CPU_COUNT(&set));
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_FALSE(CPU_ISSET(i, &set));
+  }
+}
+
+TEST(sched, cpu_clr) {
+  cpu_set_t set;
+
+  CPU_ZERO(&set);
+  CPU_SET(0, &set);
+  CPU_SET(1, &set);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 0 || i == 1, CPU_ISSET(i, &set));
+  }
+  CPU_CLR(1, &set);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 0, CPU_ISSET(i, &set));
+  }
+
+  // We should fail silently if we try to clear/test outside the range.
+  CPU_CLR(CPU_SETSIZE, &set);
+  ASSERT_FALSE(CPU_ISSET(CPU_SETSIZE, &set));
+}
+
+TEST(sched, cpu_equal) {
+  cpu_set_t set1;
+  cpu_set_t set2;
+
+  CPU_ZERO(&set1);
+  CPU_ZERO(&set2);
+  CPU_SET(1, &set1);
+  ASSERT_FALSE(CPU_EQUAL(&set1, &set2));
+  CPU_SET(1, &set2);
+  ASSERT_TRUE(CPU_EQUAL(&set1, &set2));
+}
+
+TEST(sched, cpu_op) {
+  cpu_set_t set1;
+  cpu_set_t set2;
+  cpu_set_t set3;
+
+  CPU_ZERO(&set1);
+  CPU_ZERO(&set2);
+  CPU_ZERO(&set3);
+  CPU_SET(0, &set1);
+  CPU_SET(0, &set2);
+  CPU_SET(1, &set2);
+
+  CPU_AND(&set3, &set1, &set2);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 0, CPU_ISSET(i, &set3));
+  }
+
+  CPU_XOR(&set3, &set1, &set2);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 1, CPU_ISSET(i, &set3));
+  }
+
+  CPU_OR(&set3, &set1, &set2);
+  for (int i = 0; i < CPU_SETSIZE; i++) {
+    ASSERT_EQ(i == 0 || i == 1, CPU_ISSET(i, &set3));
+  }
+}
+
+
+TEST(sched, cpu_alloc_small) {
+  cpu_set_t* set = CPU_ALLOC(17);
+  size_t size = CPU_ALLOC_SIZE(17);
+
+  CPU_ZERO_S(size, set);
+  ASSERT_EQ(0, CPU_COUNT_S(size, set));
+  CPU_SET_S(16, size, set);
+  ASSERT_TRUE(CPU_ISSET_S(16, size, set));
+
+  CPU_FREE(set);
+}
+
+TEST(sched, cpu_alloc_big) {
+  cpu_set_t* set = CPU_ALLOC(10 * CPU_SETSIZE);
+  size_t size = CPU_ALLOC_SIZE(10 * CPU_SETSIZE);
+
+  CPU_ZERO_S(size, set);
+  ASSERT_EQ(0, CPU_COUNT_S(size, set));
+  CPU_SET_S(CPU_SETSIZE, size, set);
+  ASSERT_TRUE(CPU_ISSET_S(CPU_SETSIZE, size, set));
+
+  CPU_FREE(set);
+}
+
+TEST(sched, cpu_s_macros) {
+  int set_size = 64;
+  size_t size = CPU_ALLOC_SIZE(set_size);
+  cpu_set_t* set = CPU_ALLOC(set_size);
+
+  CPU_ZERO_S(size, set);
+  for (int i = 0; i < set_size; i++) {
+    ASSERT_FALSE(CPU_ISSET_S(i, size, set));
+    CPU_SET_S(i, size, set);
+    ASSERT_TRUE(CPU_ISSET_S(i, size, set));
+    ASSERT_EQ(i + 1, CPU_COUNT_S(size, set));
+  }
+
+  for (int i = 0; i < set_size; i++) {
+    CPU_CLR_S(i, size, set);
+    ASSERT_FALSE(CPU_ISSET_S(i, size, set));
+    ASSERT_EQ(set_size - i - 1, CPU_COUNT_S(size, set));
+  }
+
+  CPU_FREE(set);
+}
+
+TEST(sched, cpu_op_s_macros) {
+  int set_size1 = 64;
+  int set_size2 = set_size1 * 2;
+  int set_size3 = set_size1 * 3;
+  size_t size1 = CPU_ALLOC_SIZE(set_size1);
+  size_t size2 = CPU_ALLOC_SIZE(set_size2);
+  size_t size3 = CPU_ALLOC_SIZE(set_size3);
+
+  cpu_set_t* set1 = CPU_ALLOC(size1);
+  cpu_set_t* set2 = CPU_ALLOC(size2);
+  cpu_set_t* set3 = CPU_ALLOC(size3);
+  CPU_ZERO_S(size1, set1);
+  CPU_ZERO_S(size2, set2);
+  CPU_ZERO_S(size3, set3);
+
+  CPU_SET_S(0, size1, set1);
+  CPU_SET_S(0, size2, set2);
+  CPU_SET_S(1, size3, set2);
+
+  CPU_AND_S(size1, set3, set1, set2);
+  for (int i = 0; i < set_size3; i++) {
+    ASSERT_EQ(i == 0, CPU_ISSET_S(i, size3, set3));
+  }
+
+  CPU_OR_S(size1, set3, set1, set2);
+  for (int i = 0; i < set_size3; i++) {
+    ASSERT_EQ(i == 0 || i == 1, CPU_ISSET_S(i, size3, set3));
+  }
+
+  CPU_XOR_S(size1, set3, set1, set2);
+  for (int i = 0; i < set_size3; i++) {
+    ASSERT_EQ(i == 1, CPU_ISSET_S(i, size3, set3));
+  }
+
+  CPU_FREE(set1);
+  CPU_FREE(set2);
+  CPU_FREE(set3);
+}
+
+TEST(sched, cpu_equal_s) {
+  int set_size1 = 64;
+  int set_size2 = set_size1 * 2;
+  size_t size1 = CPU_ALLOC_SIZE(set_size1);
+  size_t size2 = CPU_ALLOC_SIZE(set_size2);
+
+  cpu_set_t* set1 = CPU_ALLOC(size1);
+  cpu_set_t* set2 = CPU_ALLOC(size2);
+
+  CPU_ZERO_S(size1, set1);
+  CPU_ZERO_S(size2, set2);
+
+  CPU_SET_S(0, size1, set1);
+  ASSERT_TRUE(CPU_EQUAL_S(size1, set1, set1));
+  ASSERT_FALSE(CPU_EQUAL_S(size1, set1, set2));
+  CPU_SET_S(0, size2, set2);
+  ASSERT_TRUE(CPU_EQUAL_S(size1, set1, set2));
+
+  CPU_FREE(set1);
+  CPU_FREE(set2);
+}