Expose sched.h functions

Modules/posixmodule.c

 
 /* POSIX module implementation */
 
 /* This file is also used for Windows NT/MS-Win and OS/2.  In that case the
    module actually calls itself 'nt' or 'os2', not 'posix', and a few
    functions are either unimplemented or implemented differently.  The source
    assumes that for Windows NT, the macro 'MS_WINDOWS' is defined independent
    of the compiler used.  Different compilers define their own feature
    test macro, e.g. '__BORLANDC__' or '_MSC_VER'.  For OS/2, the compiler
    independent macro PYOS_OS2 should be defined.  On OS/2 the default
@@ skipping 5723 matching lines @@
     PyObject *iterable, *iterator = NULL, *item;
 
     if (!PyArg_ParseTuple(args, _Py_PARSE_PID "O:sched_setaffinity",
                           &pid, &iterable))
         return NULL;
 
     iterator = PyObject_GetIter(iterable);
     if (iterator == NULL)
         return NULL;
 
-    ncpus = 1;
+    ncpus = 16;

[storchaka, 2012/08/04 15:09:05]

"Since CPU sets are bitsets allocated in units of long words, the actual number
of CPUs in a dynamically allocated CPU set will be rounded up to the next
multiple of sizeof(unsigned long)."

    ncpus = sizeof(unsigned long) * CHAR_BIT;

[AntoinePitrou, 2012/08/04 15:14:15]

Well, starting at 16 is a heuristic. I don't really see a point in making it
more complicated.

[storchaka, 2012/08/04 15:36:25]

There is no sense to start less than sizeof(unsigned long) * CHAR_BIT. For 16
and 32 cpus same size will be allocated.

     setsize = CPU_ALLOC_SIZE(ncpus);
     mask = CPU_ALLOC(ncpus);
     if (mask == NULL) {
         PyErr_NoMemory();
         goto error;
     }
     CPU_ZERO_S(setsize, mask);
 
     while ((item = PyIter_Next(iterator))) {
         long cpu;
         if (!PyLong_Check(item)) {
             PyErr_Format(PyExc_TypeError,
                         "expected an iterator of ints, "
                         "but iterator yielded %R",
                         Py_TYPE(item));
             Py_DECREF(item);
             goto error;
         }
         cpu = PyLong_AsLong(item);
         Py_DECREF(item);
         if (cpu < 0) {
             if (!PyErr_Occurred())
                 PyErr_SetString(PyExc_ValueError, "negative CPU number");
             goto error;
         }
         if (cpu > INT_MAX - 1) {

[storchaka, 2012/08/04 15:09:05]

"The constant CPU_SETSIZE (currently 1024) specifies a value one greater than
the maximum CPU number that can be stored in cpu_set_t."

    if (cpu >= CPU_SETSIZE) {

[AntoinePitrou, 2012/08/04 15:14:15]

You can store more than CPU_SETSIZE if you allocate the cpu_set_t dynamically:

“Because some applications may require the ability to dynamically size CPU sets
(e.g., to allocate sets larger than that defined by the standard cpu_set_t data
type), glibc nowadays provides a set of macros
to support this.”

[storchaka, 2012/08/04 15:36:25]

You're right. I'm wrong.

             PyErr_SetString(PyExc_OverflowError, "CPU number too large");
             goto error;
         }
         if (cpu >= ncpus) {
             /* Grow CPU mask to fit the CPU number */
             int newncpus = ncpus;

[storchaka, 2012/08/04 15:09:05]

I don't see usage of old ncpus in this block. Is newncpus variable unnecessary?

[AntoinePitrou, 2012/08/04 15:14:15]

I find it more readable.

             cpu_set_t *newmask;
             size_t newsetsize;
             while (newncpus <= cpu) {
                 if (newncpus > INT_MAX / 2)

[storchaka, 2012/08/04 15:09:05]

    if (newncpus > CPU_SETSIZE / 2)
        newncpus = CPU_SETSIZE;
    else
        newncpus *= 2;

[AntoinePitrou, 2012/08/04 15:14:15]

No, see above.

                     newncpus = cpu + 1;
                 else
                     newncpus = newncpus * 2;
             }
             newmask = CPU_ALLOC(newncpus);
             if (newmask == NULL) {
                 PyErr_NoMemory();
                 goto error;
             }
             newsetsize = CPU_ALLOC_SIZE(newncpus);
@@ skipping 33 matching lines @@
     pid_t pid;
     int cpu, ncpus, count;
     size_t setsize;
     cpu_set_t *mask = NULL;
     PyObject *res = NULL;
 
     if (!PyArg_ParseTuple(args, _Py_PARSE_PID ":sched_getaffinity",
                           &pid))
         return NULL;
 
     ncpus = 16;

[storchaka, 2012/08/04 15:09:05]

    ncpus = sizeof(unsigned long) * CHAR_BIT;

     while (1) {
         setsize = CPU_ALLOC_SIZE(ncpus);
         mask = CPU_ALLOC(ncpus);
         if (mask == NULL)
             return PyErr_NoMemory();
         if (sched_getaffinity(pid, setsize, mask) == 0)
             break;
         CPU_FREE(mask);
         if (errno != EINVAL)
             return posix_error();
         if (ncpus > INT_MAX / 2) {

[storchaka, 2012/08/04 15:09:05]

    if (newncpus >= CPU_SETSIZE) {
        PyErr_SetString(PyExc_OverflowError, "could not allocate "
                        "a large enough CPU set");
        return NULL;
    }
    if (ncpus > CPU_SETSIZE / 2)
        ncpus = CPU_SETSIZE;
    else
        ncpus *= 2;

[AntoinePitrou, 2012/08/04 15:14:15]

Again, see above about dynamically-allocated cpu_set_t's.

             PyErr_SetString(PyExc_OverflowError, "could not allocate "
                             "a large enough CPU set");
             return NULL;
         }
         ncpus = ncpus * 2;
     }
 
     res = PySet_New(NULL);
     if (res == NULL)
         goto error;
     for (cpu = 0, count = CPU_COUNT_S(setsize, mask); count; cpu++) {
         if (CPU_ISSET_S(cpu, setsize, mask)) {
             PyObject *cpu_num = PyLong_FromLong(cpu);
             --count;
             if (cpu_num == NULL)
                 goto error;
             if (PySet_Add(res, cpu_num)) {
                 Py_DECREF(cpu_num);
                 goto error;
             }
             Py_DECREF(cpu_num);
         }
     }
     CPU_FREE(mask);
     return res;
 
 error:
     if (mask)

[storchaka, 2012/08/04 15:09:05]

mask always is not NULL.

[AntoinePitrou, 2012/08/04 15:14:15]

True.

         CPU_FREE(mask);
     Py_XDECREF(res);
     return NULL;
 }
 
 #endif /* HAVE_SCHED_SETAFFINITY */
 
 #endif /* HAVE_SCHED_H */
 
 /* AIX uses /dev/ptc but is otherwise the same as /dev/ptmx */
@@ skipping 6063 matching lines @@
 
     initialized = 1;
 
     return m;
 
 }
 
 #ifdef __cplusplus
 }
 #endif