The openMosix HOWTO:
Prev | Chapter 12. Common Problems | Next

# 12.2. My processes won't migrate

Help process XYZ doesn't migrate. Moshe Bar explains below why some processes migrate and why some don't. But before that you can always look in /proc/$pid/, there often is a cantmove file which will tell you why a certain process can't migrate.

Processes can also be locked. You can check if a process is locked with:

    cat /proc/$PID/lock

where $PID is the processid of the process in question.

Now listen to what Moshe himself has to say about this topic.

Often people have the same kernel but on a different distribution, say a mixed environment of RedHat and Debian ,rc scripts from different distros tend to start openmosix differently. Some implementations completely modify /etc/inittab to start all daemons (and their children) with

    mosrun -h

. So that they won't migrate. Therefore all these processes have a 1 in /proc/pid/lock when you start. You can force them to migrate by writing a 0 to this file .

Ok, this simple program should always migrate if launched more times than number of local CPUs. So for a 2-way SMP system, starting this program 3 times will start migration if the other nodes in the cluster have at least the same speed like the local ones:

    int main() {
        unsigned int i;
        while (1) {
            i++;
        }
        return 0;
    }

On a Pentium 800Mhz CPU it takes quite a while to overflow.

This sample program with content like this will never migrate:

    #include <sys/types.h>
    #include <sys/ipc.h>
    #include <sys/shm.h>

    ...

    key_t key; /* key to be passed to shmget() */
    int shmflg; /* shmflg to be passed to shmget() */
    int shmid; /* return value from shmget() */
    int size; /* size to be passed to shmget() */

    ...

    key = ...
    size = ...
    shmflg) = ...

    if ((shmid = shmget (key, size, shmflg)) == -1) {
       perror("shmget: shmget failed"); exit(1); } else {
       (void) fprintf(stderr, "shmget: shmget returned %d\n", shmid);
       exit(0);
      }
    ...

Program using pipes like this do migrate nicely:

    int pdes[2];

    pipe(pdes);
    if ( fork() == 0 )
      { /* child */
                                     close(pdes[1]); /* not required */
                                     read( pdes[0]); /* read from parent */
                                     .....
                     }
    else
                     { close(pdes[0]); /* not required */
                                     write( pdes[1]); /* write to child */
                                     .....
                     }

MODIFIED Programs using pthreads since version 2.4.17 don't migrate, however they don't segfault anymore.

    //
    // Very simple program demonstrating the use of threads.
    //
    // Command-line argument is P (number of threads).
    //
    // Each thread writes "hello" message to standard output, with
    //   no attempt to synchronize.  Output will likely be garbled.
    //
    #include <iostream>
    #include <cstdlib>              // has exit(), etc.
    #include <unistd.h>             // has usleep()
    #include <pthread.h>            // has pthread_ routines

    // declaration for function to be executed by each thread
    void * printHello(void * threadArg);

    // ---- Main program -------------------------------------------------

    int main(int argc, char* argv[]) {

      if (argc < 2) {
        cerr << "Usage:  " << argv[0] << " numThreads\n";
        exit(EXIT_FAILURE);
      }
      int P = atoi(argv[1]);

      // Set up IDs for threads (need a separate variable for each
      //   since they're shared among threads).
      int * threadIDs = new int[P];
      for (int i = 0; i < P; ++i)
        threadIDs[i] = i;

      // Start P new threads, each with different ID.
      pthread_t * threads = new pthread_t[P];
      for (int i = 0; i < P; ++i)
        pthread_create(&threads[i], NULL, printHello,
                       (void *) &threadIDs[i]);

      // Wait for all threads to complete.
      for (int i = 0; i < P; ++i)
        pthread_join(threads[i], NULL);

      // Clean up and exit.
      delete [] threadIDs;
      delete [] threads;
      cout << "That's all, folks!\n";
      return EXIT_SUCCESS;
    }

    // ---- Code to be executed by each thread ---------------------------

    // pre:  *threadArg is an integer "thread ID".
    // post:  "hello" message printed to standard output.
    //        return value is null pointer.
    void * printHello(void * threadArg) {
      int * myID = (int *) threadArg;
      cout << "hello, world, ";
      // pointless pause, included to make the effects of
      //   synchronization (or lack thereof) more obvious
      usleep(10);
      cout << "from thread " << *myID << endl;
      pthread_exit((void* ) NULL);
    }

Programs using all kinds of file descriptors, including sockets do migrate (sockets are not migrated with the process however, files are migrated if using oMFS/DFSA)

(all above code is by Moshe as Moshe Bar or by Moshe as CTO of Qlusters, Inc.)

Please also refer to the man pages of openMosix , they also give an adequate explanation why processes don't migrate.

If for some reason your processes stay locked while they shouldn't. You can try to allow locked processes to migrate by simply putting

    # tell shells to allow subprocs to migrate to other nodes
    echo 0 > /proc/self/lock

into "/etc/profile" Warning : this fix will allow all process to migrate not just the ones you want. To only allow specific process to migrate use 'mosrun -l' to unlock only the desired process.

Prev | Home | Next
Introduction | Up | I don't see all my nodes