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
diff --git a/tests/sched_test.cpp b/tests/sched_test.cpp
index 49f1642..2578289 100644
--- a/tests/sched_test.cpp
+++ b/tests/sched_test.cpp
@@ -50,3 +50,207 @@
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);
+}