mutex on multiple cpus

[jason williams]

I am learning mutex lately. So I wrote programs for practicing this issue on multiple cpus. However, it seems there is a problem for my code but I am not aware of where goes wrong.

Code are as below:

    
import mutex.Lock;
import mutex.Mutex;
public class Test{
       public static void main(String args[]){
                new Test().process();
        }

        void process(){
                int cnt = 0;
                Lock lock = new Mutex(5);
                inc(5, lock);
        }
        void inc(int np, Lock lock){
                MyThread t[] = new MyThread[np];
                for(int i=0;i<np;i++){
                        t[i] = new MyThread(i, lock);
                        t[i].start();
                        System.out.println("count value:t["+i+"]"+t[i].getCountValue());
                }
        }
}

   
import mutex.Lock;
import mutex.Mutex;
public class MyThread extends Thread{
        private int pid;
        private Lock lock;
        private static int count = 0;

        public MyThread(int pid, Lock lock){
                this.pid = pid;
                this.lock = lock;
        }

        public void run(){
                this.lock.lock(this.pid);
                        increament();
                        //decreament();
                this.lock.unlock(this.pid);
        }

        public void increament(){
                count++;
        }

        public void decreament(){
                count--;
        }

        public int getCountValue(){
                return this.count;
        }
}


 

package mutex;

public interface Lock{
        void lock(int pid);
        void unlock(int pid);
}

package mutex;

public class Mutex implements Lock{
        int N;
        boolean takeANumber[];
        int valueOfProcess[];
        public Mutex(int n){
                this.N = n;
                takeANumber = new boolean[N];
                valueOfProcess = new int[N];
                for(int i=0;i<N;i++){
                        takeANumber[i] = false;
                        valueOfProcess[i] = 0;
                }
        }

        public void lock(int pid){
                takeANumber[pid] = true;
                for(int i=0;i<N;i++){
                        if(valueOfProcess[i]>valueOfProcess[pid]){
                                valueOfProcess[pid] = valueOfProcess[i];
                        }
                }
                valueOfProcess[pid]++; 
                takeANumber[pid] = false;

                for(int i=0;i<N;i++){
                        while(takeANumber[i]); 

Result shows

count value:t[0]1
count value:t[1]1
count value:t[2]2
count value:t[3]3
count value:t[4]4

The value obtained by thread 0 and 1 are the same, which seems incorrect.

Does which parts of the code go wrong? Or is there any tutorial or resource with actual code telling how to write mutex on multiple cpu or smp?
Thanks for help.

[Henry Wong]

Although, your code has "Lock" and "Mutex" as names, there are no locks or mutexes anywhere to be seen.

In order to implement a mutex, you need to have the lock() and unlock() methods be completely atomic -- which yours are not. And to do that, you have a few options...

You can use synchronization -- which itself can be considered a mutex... so no need to implement one yourself.

You can use the atomic classes (located in java.util.concurrent.atomic package) which can make your methods behave atomically. Although admittedly, this is not for the faint of heart, as optimistic locking is an advanced topic.

Or you can use the lock classes (located in java.util.concurrent.locks) which implements mutexes, reader-writer locks, semaphores, etc. And done so optimistically, and very efficiently. So, no need to implement your own mutex class.

Henry

[jason williams]

Henry Wong wrote:Although, your code has "Lock" and "Mutex" as names, there are no locks or mutexes anywhere to be seen.

In order to implement a mutex, you need to have the lock() and unlock() methods be completely atomic -- which yours are not. And to do that, you have a few options...

You can use synchronization -- which itself can be considered a mutex... so no need to implement one yourself.

You can use the atomic classes (located in java.util.concurrent.atomic package) which can make your methods behave atomically. Although admittedly, this is not for the faint of heart, as optimistic locking is an advanced topic.

Or you can use the lock classes (located in java.util.concurrent.locks) which implements mutexes, reader-writer locks, semaphores, etc. And done so optimistically, and very efficiently. So, no need to implement your own mutex class.

Henry

Sorry the code is not listed completely.
My impl of Mutex is as below. And these code are just for practise for myself to have better understanding on how mutex works.
Thanks for help.

package mutex;

public class Mutex implements Lock{
        int N;
        boolean takeANumber[];
        int valueOfProcess[];
        public Mutex(int n){
                this.N = n;
                takeANumber = new boolean[N];
                valueOfProcess = new int[N];
                for(int i=0;i<N;i++){
                        takeANumber[i] = false;
                        valueOfProcess[i] = 0;
                }
        }

        public void lock(int pid){

                takeANumber[pid] = true;
                for(int i=0;i<N;i++){
                        if(valueOfProcess[i]>valueOfProcess[pid]){
                                valueOfProcess[pid] = valueOfProcess[i];
                        }
                }
                valueOfProcess[pid]++; // line up
                takeANumber[pid] = false;


                for(int i=0;i<N;i++){
                        while(takeANumber[i]); 
                        while((valueOfProcess[i]!=0 &&
                                ((valueOfProcess[i]<valueOfProcess[pid])||
                                (valueOfProcess[i]==valueOfProcess[pid]&&i<pid)))); 
                }
        }

        public void unlock(int pid){
                valueOfProcess[pid] = 0;
        }
}