├── Basic_data.txt
├── .DS_Store
├── PSO
    ├── Int.class
    ├── Pso.class
    ├── Doubl.class
    ├── Driver.class
    ├── Server.class
    ├── TaskInfo.class
    ├── GbestInfo.class
    ├── RandomPso.class
    ├── ObjToClient.class
    ├── OrthogonalPso.class
    ├── SAnnealingPso.class
    ├── ModifiedNewPso.class
    ├── MultiThreadPso.class
    ├── ParallelPso_Client.class
    ├── ParallelPso_Server.class
    ├── VariableInertiaPso.class
    └── ParallelOrthogonalPso_Server.class
├── newiter.xls
├── VariableInertiaPso.java
├── static_input.txt
├── MultiThreadPso.java
├── OrthogonalPso.java
├── ParallelOrthogonalPso_Server.java
├── ModifiedNewPso.java
├── pso_instructions.txt
├── RandomPso.java
├── TaskInfo.java
├── ParallelPso_Client.java
├── Driver.java
├── SAnnealingPso.java
├── ParallelPso_Server.java
└── Pso.java


/Basic_data.txt:
--------------------------------------------------------------------------------
1 | 5
2 | 20
3 | 100
4 | 50
5 | 5


--------------------------------------------------------------------------------
/.DS_Store:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/.DS_Store


--------------------------------------------------------------------------------
/PSO/Int.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/Int.class


--------------------------------------------------------------------------------
/PSO/Pso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/Pso.class


--------------------------------------------------------------------------------
/newiter.xls:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/newiter.xls


--------------------------------------------------------------------------------
/PSO/Doubl.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/Doubl.class


--------------------------------------------------------------------------------
/PSO/Driver.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/Driver.class


--------------------------------------------------------------------------------
/PSO/Server.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/Server.class


--------------------------------------------------------------------------------
/PSO/TaskInfo.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/TaskInfo.class


--------------------------------------------------------------------------------
/PSO/GbestInfo.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/GbestInfo.class


--------------------------------------------------------------------------------
/PSO/RandomPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/RandomPso.class


--------------------------------------------------------------------------------
/PSO/ObjToClient.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/ObjToClient.class


--------------------------------------------------------------------------------
/PSO/OrthogonalPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/OrthogonalPso.class


--------------------------------------------------------------------------------
/PSO/SAnnealingPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/SAnnealingPso.class


--------------------------------------------------------------------------------
/PSO/ModifiedNewPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/ModifiedNewPso.class


--------------------------------------------------------------------------------
/PSO/MultiThreadPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/MultiThreadPso.class


--------------------------------------------------------------------------------
/PSO/ParallelPso_Client.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/ParallelPso_Client.class


--------------------------------------------------------------------------------
/PSO/ParallelPso_Server.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/ParallelPso_Server.class


--------------------------------------------------------------------------------
/PSO/VariableInertiaPso.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/VariableInertiaPso.class


--------------------------------------------------------------------------------
/PSO/ParallelOrthogonalPso_Server.class:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/gowth08/PSO/HEAD/PSO/ParallelOrthogonalPso_Server.class


--------------------------------------------------------------------------------
/VariableInertiaPso.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | import java.io.*;
 3 | import java.util.*;
 4 | class VariableInertiaPso extends Pso
 5 | {
 6 | 	public double update(double w)
 7 | 	{
 8 | 		return ((.9-.4)*cur_iter_no)/max_iterate;
 9 | 	}
10 | }


--------------------------------------------------------------------------------
/static_input.txt:
--------------------------------------------------------------------------------
 1 | 54 79 16 66 58 
 2 | 83 3 89 58 56 
 3 | 15 11 49 31 20 
 4 | 71 99 15 68 85 
 5 | 77 56 89 78 53 
 6 | 36 70 45 91 35 
 7 | 53 99 60 13 53 
 8 | 38 60 23 59 41 
 9 | 27 5 57 49 69 
10 | 87 56 64 85 13 
11 | 79 16 66 58 86 
12 | 3 89 58 56 72 
13 | 11 49 31 20 8 
14 | 99 15 68 85 49 
15 | 56 89 78 53 47 
16 | 70 45 91 35 87 
17 | 99 60 13 53 58 
18 | 60 23 59 41 18 
19 | 5 57 49 69 68 
20 | 56 64 85 13 28 
21 | 


--------------------------------------------------------------------------------
/MultiThreadPso.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | 
 3 | import java.io.*;
 4 | import java.util.*;
 5 | 
 6 | public class MultiThreadPso extends Pso implements Runnable
 7 | {
 8 | 	Thread t;
 9 | 	MultiThreadPso()
10 | 	{
11 | 		bInit();
12 | 		t=new Thread(this);
13 | 		init();
14 | 		t.start();
15 | 	}
16 | 	public double update(double w)
17 | 	{
18 | 		return ((.9-.4)*cur_iter_no)/max_iterate;
19 | 	}
20 | 	public void run()
21 | 	{
22 | 	
23 | 		generate();
24 | 		iterate();
25 | 	}
26 | }


--------------------------------------------------------------------------------
/OrthogonalPso.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | import java.io.*;
 3 | import java.util.*;
 4 | class OrthogonalPso extends Pso
 5 | {
 6 | 	public double update(double w)
 7 | 	{
 8 | 	      	return ((.9-.4)*cur_iter_no)/max_iterate;
 9 | 	}
10 | 	public void generate()
11 | 	{
12 | 		int Q,N,M,J,k,j,x,i,s,t;
13 | 		TaskInfo TIrhs,TIj,TIs;
14 | 		M=no_of_particles;
15 | 		N=no_of_tasks;
16 | 		Q=no_of_processors;
17 | 		J=(int)Math.ceil(Math.log((double)N*(Q-1)+1));
18 | 		int y=(int)Math.pow(Q,J);
19 | 		for(k=1;k<=J;k++)
20 | 		{
21 | 			
22 | 			j=(int)(Math.pow(Q,k-1)-1)/(Q-1);
23 | 			if(j>=N)break;
24 | 			for(i=0;i<M;i++)
25 | 			{
26 | 				((TaskInfo)tasks.get(j)).allocation[i]=(int)Math.floor((i-1)/(Math.pow(Q,J-k)))%Q+1;
27 | 			}
28 | 		}
29 | 		
30 | 		for(k=2;k<=J;k++)
31 | 		{
32 | 			j=(int)(Math.pow(Q,k-1)-1)/(Q-1);
33 | 			if(j>=N)break;
34 | 			TIj=(TaskInfo)tasks.get(j);
35 | 			for(s=1;s<j;s++)
36 | 			{
37 | 				TIs=(TaskInfo)tasks.get(s);
38 | 				for(t=1;t<=Q;t++)
39 | 				{
40 | 					x=(s-1)*(Q-1)+t+j-1;
41 | 					if(x>=N)break;
42 | 					TIrhs=(TaskInfo)tasks.get(x);
43 | 					for(i=0;i<M;i++)
44 | 					{
45 | 						TIrhs.allocation[i]=(TIs.allocation[i]*t+TIj.allocation[i])%Q+1;
46 | 					}
47 | 				}
48 | 			}		
49 | 		}
50 | 		for( j=0;j<no_of_particles;j++)
51 | 		{
52 | 			fit_calc(j);
53 | 		}	
54 | 	}
55 | 	
56 | }


--------------------------------------------------------------------------------
/ParallelOrthogonalPso_Server.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | import java.io.*;
 3 | import java.util.*;
 4 | import java.net.*;
 5 | public class ParallelOrthogonalPso_Server extends ParallelPso_Server
 6 | {
 7 | 	
 8 | 	//public ParallelOrthogonalPso(){}
 9 | 	public ParallelOrthogonalPso_Server(int n)
10 | 	{
11 | 		super(n);
12 | 	}
13 | 	
14 | 	public void generate()
15 | 	{
16 | 			int Q,N,M,J,k,j,x,i,s,t;
17 | 		TaskInfo TIrhs,TIj,TIs;
18 | 		M=no_of_particles;
19 | 		N=no_of_tasks;
20 | 		Q=no_of_processors;
21 | 		J=(int)Math.ceil(Math.log((double)N*(Q-1)+1));
22 | 		int y=(int)Math.pow(Q,J);
23 | 		for(k=1;k<=J;k++)
24 | 		{
25 | 			
26 | 			j=(int)(Math.pow(Q,k-1)-1)/(Q-1);
27 | 			if(j>=N)break;
28 | 			for(i=0;i<M;i++)
29 | 			{
30 | 				((TaskInfo)tasks.get(j)).allocation[i]=(int)Math.floor((i-1)/(Math.pow(Q,J-k)))%Q+1;
31 | 			}
32 | 		}
33 | 		
34 | 		for(k=2;k<=J;k++)
35 | 		{
36 | 			j=(int)(Math.pow(Q,k-1)-1)/(Q-1);
37 | 			if(j>=N)break;
38 | 			TIj=(TaskInfo)tasks.get(j);
39 | 			for(s=1;s<j;s++)
40 | 			{
41 | 				TIs=(TaskInfo)tasks.get(s);
42 | 				for(t=1;t<=Q;t++)
43 | 				{
44 | 					x=(s-1)*(Q-1)+t+j-1;
45 | 					if(x>=N)break;
46 | 					TIrhs=(TaskInfo)tasks.get(x);
47 | 					for(i=0;i<M;i++)
48 | 					{
49 | 						TIrhs.allocation[i]=(TIs.allocation[i]*t+TIj.allocation[i])%Q+1;
50 | 					}
51 | 				}
52 | 			}		
53 | 		}
54 | 	}	
55 | }


--------------------------------------------------------------------------------
/ModifiedNewPso.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | import java.io.*;
 3 | import java.util.*;
 4 | class ModifiedNewPso extends Pso
 5 | {
 6 | 	public double update(double w)
 7 | 	{
 8 | 		return ((.9-.4)*cur_iter_no)/max_iterate;
 9 | 	}
10 | 
11 | 	public void iterate()
12 | 	{
13 | 		double w=0.9;
14 | 		LinkedList vel[]=new LinkedList[no_of_particles];
15 | 		Doubl v;
16 | 		int i,j,k,pb,gb,pc;
17 | 		
18 | 		for(i=0;i<no_of_particles;i++)
19 | 		{
20 | 			vel[i]=new LinkedList();
21 | 			for(j=0;j<no_of_tasks;j++)
22 | 			{
23 | 				vel[i].add(new Doubl(0.0));
24 | 			}
25 | 		}
26 | 		for(cur_iter_no=1;cur_iter_no<=max_iterate;cur_iter_no++)
27 | 		{
28 | 			for(j=0;j<no_of_particles;j++)
29 | 			{
30 | 				for(k=0;k<no_of_tasks;k++)
31 |     			{
32 | 					v=(Doubl)vel[j].get(k);
33 | 					pb=((Int)pbest[j].get(k)).val;
34 | 					gb=((Int)gbest.get(k)).val;
35 | 					pc=((TaskInfo)tasks.get(k)).allocation[j];
36 | 					v.val=w*v.val+2*(Math.random()*(pc-pb)+Math.random()*(pc-gb));
37 | 					((TaskInfo)tasks.get(k)).allocation[j]=(int)(Math.abs(pc+v.val+0.5)%no_of_processors)+1;
38 | 				}
39 | 				fit_calc(j);
40 | 			}
41 | 		w=update(w);
42 | 		}
43 | 	}	public void disp()
44 | 	{
45 | 		System.out.println ("Best Allocation : ");
46 | 		for(int i=0;i<no_of_tasks;i++)
47 | 			System.out.print(((Int)gbest.get(i)).val+" ");
48 | 		System.out.println("\nCost : "+gbestv+"\nNo. of Iterations : "+gbest_iter_no);
49 | 	
50 | 		
51 | 	}
52 | }


--------------------------------------------------------------------------------
/pso_instructions.txt:
--------------------------------------------------------------------------------
 1 | PLEASE NOTE
 2 | ===========
 3 | The classes used are listed below ( compilation should be in the order)
 4 | 
 5 | 1.The files marked (*) are executable class files
 6 | 2.The user is requested to compile all files atleast once and then execute the     appropriate driver files
 7 | ===============================================================================
 8 | java files :
 9 | ===============================================================================
10 | 1.TaskInfo 
11 | 2.Pso
12 | 3.Pso_driver(*)
13 | 4.VariableInertiaPso
14 | 5.VIPso_driver(*)
15 | 6.RandomPso
16 | 7.Rpso_driver(*)
17 | 8.MultiThreadPso
18 | 9.MtPso_driver(*)
19 | 10.ParallelPso_Client
20 | 11.ParallelPso_Server
21 | 12.ParallelPso_driver(*)
22 | 13.OrthogonalPso
23 | 14.OrthogonalPso_driver(*)
24 | 15.ParallelOrthogonalPso
25 | 16.ParallelOrthogonalPso_driver(*)
26 | 17.ModifiedNewPso
27 | 18.MN_Pso_driver(*)
28 | 19.SimulatedAnnealingPso
29 | 20.SimulatedAnnealingPso_driver(*)
30 | ================================================================================
31 | Text files
32 | ================================================================================
33 | 1.Basic_data
34 | 		contains integers in the order
35 | 			no of processors
36 | 			no of tasks
37 | 			no of particles
38 | 			maximum no of iterations
39 | 			set size(only for random pso)
40 | 2.Static_input
41 | 		contains three fields
42 | 			task_name arrival_time execution_time
43 | 			


--------------------------------------------------------------------------------
/RandomPso.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | 
 3 | import java.io.*;
 4 | import java.util.*;
 5 | 
 6 | public class RandomPso extends Pso
 7 | {
 8 | 	int no_of_sets;
 9 | 	int set_no;
10 | 	public void bInit()
11 | 	{
12 | 		super.bInit();
13 | 		for(int i=0;i<no_of_tasks;i++)
14 | 			gbest.add(new Int(0));
15 | 		try 
16 | 		{
17 | 			no_of_sets=Integer.parseInt(in.readLine());
18 | 	    }
19 | 	    catch (Exception ex) {}
20 | 		
21 | 		max_iterate/=no_of_sets;
22 | 	}
23 | 	public double update(double w)
24 | 	{
25 | 		return ((.9-.4)*cur_iter_no)/max_iterate;
26 | 	}
27 | 	public void init()
28 | 	{
29 | 		
30 | 		TaskInfo task;
31 | 		int i,j;
32 | 		tasks=new LinkedList();	
33 | 		for(i=0;i<no_of_particles;i++)
34 | 		{
35 | 			pbest[i]=new LinkedList();
36 | 			for(j=0;j<no_of_tasks;j++)
37 | 				pbest[i].add(new Int(0));
38 | 		}
39 | 		TaskInfo.init();
40 | 		for( i=0;i<no_of_tasks;i++)
41 | 		{
42 | 			task=new TaskInfo();
43 | 			task.set();
44 | 			tasks.add(task);
45 | 		
46 | 		}
47 | 		TaskInfo.close();
48 | 		
49 | 	}
50 | 	
51 | 	public void iterate()
52 | 	{
53 | 	double prevgb=gbestv;
54 | 	int cur_set_no;
55 | 	for ( cur_set_no = 1; cur_set_no<no_of_sets; cur_set_no++)	
56 | 	{
57 | 		super.iterate();
58 | 	
59 | 	
60 | 		if(prevgb!=gbestv)
61 | 		{
62 | 				set_no=cur_set_no;
63 | 				prevgb=gbestv;
64 | 		}
65 | 		
66 | 		init();
67 | 		generate();
68 | 		
69 | 	}
70 | 	super.iterate();
71 | 	if(prevgb!=gbestv)
72 | 			set_no=cur_set_no;
73 | 		
74 | 	}
75 | 	
76 | 	public void disp()
77 | 	{
78 | 		super.disp();
79 | 		System.out.println("set no :"+set_no );
80 | 	}
81 | }


--------------------------------------------------------------------------------
/TaskInfo.java:
--------------------------------------------------------------------------------
 1 | /* A Java implementation for "Multiprocessor Scheduling using Particle Swarm Optimization"
 2 |  * All classes required are in the PSO package
 3 |  * class --- TaskInfo
 4 |  * This class holds the  information required about - tasks , processors , paricle_size 
 5 |  * - allocation of tasks to processors in a particular particle etc
 6 |  * reads the data from the "static_input.txt" file which contains data in the following format
 7 |  * task_name arrival_time execution_time 
 8 |  */
 9 | package PSO;
10 | import java.io.*;
11 | import java.util.*;
12 | class TaskInfo implements Serializable
13 | {
14 | 	public int exec_t[];
15 | 	public int allocation[];
16 | 	public static int no_of_particles;
17 | 	public static int no_of_processors;
18 | 	private static BufferedReader in;
19 | 	public static void init()
20 | 	{
21 | 		try
22 | 		{
23 | 			in=new BufferedReader(new FileReader("static_input.txt"));
24 | 		}catch(Exception e){}
25 | 	}
26 | 	//initializes the allocation array to the particle size provided by the "basic_data" file
27 | 	TaskInfo()
28 | 	{
29 | 		allocation=new int[no_of_particles];
30 | 		exec_t=new int[no_of_processors];
31 | 	}
32 | 	/* this method reads one line from the file,tokenizes it and
33 | 	 * initializes the data members of the TaskInfo class
34 | 	 */
35 | 	public void set()
36 | 	{
37 | 		StringTokenizer st;
38 | 		String line;
39 | 		try
40 | 		{
41 | 			st=new StringTokenizer(in.readLine());
42 | 			for (int i = 0;st.hasMoreTokens(); i++)
43 | 			exec_t[i]=Integer.parseInt(st.nextToken());
44 | 		}catch(Exception e){}
45 | 	}
46 | 	
47 | 	public static void close()
48 | 	{
49 | 		try 
50 | 		{
51 | 			in.close();
52 | 	    }
53 | 	    catch (Exception ex) {}
54 | 		
55 | 	}
56 | }


--------------------------------------------------------------------------------
/ParallelPso_Client.java:
--------------------------------------------------------------------------------
 1 | package PSO;
 2 | import java.io.*;
 3 | import java.util.*;
 4 | import java.net.*;
 5 | 
 6 | class GbestInfo implements Serializable
 7 | {
 8 | 	LinkedList gb;
 9 | 	double cost;
10 | 	GbestInfo(LinkedList gb,double cost)
11 | 	{
12 | 		this.gb=gb;
13 | 		this.cost=cost;	
14 | 	}
15 | 	
16 | }
17 | class ParallelPso_Client extends Pso implements Runnable
18 | {
19 | 	Socket s;
20 | 	Thread t;
21 | 	ObjToClient otc;
22 | 	ObjectOutputStream oos;
23 | 	ObjectInputStream ois;
24 | 	public void init()
25 | 	{
26 | 		try 
27 | 		{
28 | 			s=new Socket(InetAddress.getLocalHost(),2000);
29 | 		}
30 | 	    catch (Exception ex) {System.out.println (ex);}
31 | 	    t=new Thread(this);
32 | 	    
33 | 		
34 | 	}
35 | 	
36 | 
37 | 	public double update(double w)
38 | 	{
39 | 		
40 |    	 	GbestInfo gi=new GbestInfo(gbest,gbestv);
41 |    	 	try 
42 |   		{
43 |   			oos.writeObject(gi);
44 |   			gi=(GbestInfo)ois.readObject();
45 | 		}catch (Exception ex) {System.out.println (ex);}
46 | 		gbest=new LinkedList(gi.gb);
47 | 		gbestv=gi.cost;
48 | 			return ((.9-.4)*cur_iter_no)/max_iterate;
49 | 	}
50 | 	
51 | 	public void run()
52 | 	{  
53 | 		
54 | 	    
55 | 	    int i,j;
56 | 		try
57 | 		{
58 | 		
59 | 		
60 | 	    	ois = new ObjectInputStream(s.getInputStream());
61 | 		
62 | 	    	
63 | 			oos = new ObjectOutputStream(s.getOutputStream());
64 | 		
65 | 
66 | 	    	otc=(ObjToClient)ois.readObject();
67 | 	    	
68 | 	    	tasks=otc.tasks;
69 | 	    	
70 | 		
71 | 	    	no_of_processors=otc.no_of_processors;
72 | 			no_of_tasks=otc.no_of_tasks;
73 | 			no_of_particles=otc.no_of_particles;
74 | 			max_iterate=otc.max_iterate;
75 | 			gbest=new LinkedList(otc.gbest);
76 | 			pbest=new LinkedList[no_of_particles];
77 | 			pbestv=new double[no_of_particles];
78 | 			gbestv=otc.gbestv;
79 | 		
80 | 				
81 | 		
82 | 		}catch(Exception e){System.out.println (e);}
83 | 		
84 | 		for(i=0;i<no_of_particles;i++)
85 | 			pbest[i]=new LinkedList(otc.pbest[i]);
86 | 		iterate();
87 |   			
88 |   			
89 |    	}
90 |  }


--------------------------------------------------------------------------------
/Driver.java:
--------------------------------------------------------------------------------
  1 | /*A driver class for all the classes
  2 |  */
  3 | package PSO;
  4 | class Driver
  5 | {
  6 | 	public static void main(String a[])
  7 | 	{
  8 | 		
  9 | 		int i;
 10 | 		Pso p=new Pso();
 11 | 		int iterate_sum=0;
 12 | 		double gbest_sum=0;
 13 | 		System.out.println ("Pso : ");
 14 | 		System.out.println ("Pso\ncost: "+call(new Pso()));
 15 | 		System.out.println ("\nVariableInertiaPso:\ncost: "+call(new VariableInertiaPso()));
 16 | 		System.out.println ("\n\nModifiedNewPso :\ncost "+call(new ModifiedNewPso()));
 17 | 		System.out.println ("\n\nRandomPso :\ncost "+call(new RandomPso()));
 18 | 		System.out.println ("\n\nOrthogonalPso :\ncost "+call(new OrthogonalPso()));
 19 | 		System.out.println ("\n\nSAPso :\ncost "+call(new SAnnealingPso()));
 20 | 		
 21 | 		System.out.println ("\n\nMultiThreadedPso : ");
 22 | 		for(i=0;i<10;i++)
 23 | 		{
 24 | 		MTPso_driver();
 25 | 			iterate_sum+=p.gbest_iter_no;
 26 | 			gbest_sum+=p.gbestv;
 27 | 		}
 28 | 		System.out.println ("Iterations: "+iterate_sum/10+"\nGbest : "+gbest_sum/10);
 29 | 		iterate_sum=0;
 30 | 		 gbest_sum=0;
 31 | 		System.out.println ("\n\nParallelPso : ");
 32 | 		for(i=0;i<10;i++)
 33 | 		{
 34 | 		ParallelPso_driver(new ParallelPso_Server(10),10);
 35 | 			iterate_sum+=p.gbest_iter_no;
 36 | 			gbest_sum+=p.gbestv;
 37 | 		}
 38 | 		System.out.println ("Iterations: "+iterate_sum/10+"\nGbest : "+gbest_sum/10);
 39 | 		System.out.println ("\n\nParallelOrthogonalPso : ");
 40 | 		iterate_sum=0;
 41 | 		 gbest_sum=0;
 42 | 		for(i=0;i<10;i++)
 43 | 		{
 44 | 		ParallelPso_driver(new ParallelOrthogonalPso_Server(10),10);
 45 | 			iterate_sum+=p.gbest_iter_no;
 46 | 			gbest_sum+=p.gbestv;
 47 | 		
 48 | 		}
 49 | 		System.out.println ("Iterations: "+iterate_sum/10+"\nGbest : "+gbest_sum/10);
 50 | 	}
 51 | 	
 52 | 	private static double call(Pso p)
 53 | 	{
 54 | 		
 55 | 		int iterate_sum=0;
 56 | 		double gbest_sum=0;
 57 | 		p.bInit();
 58 | 		p.init();
 59 | 		p.generate();
 60 | 		for(int i=0;i<10;i++)
 61 | 		{
 62 | 			p.iterate();
 63 | 			iterate_sum+=p.gbest_iter_no;
 64 | 			gbest_sum+=p.gbestv;
 65 | 		}
 66 | 		
 67 | 	//	p.disp();		
 68 | 	
 69 | 	return gbest_sum/10;
 70 | 		
 71 | 	}
 72 | 	private static void MTPso_driver()
 73 | 	{
 74 | 		MultiThreadPso p1=new MultiThreadPso();
 75 | 		MultiThreadPso p2=new MultiThreadPso();
 76 | 		MultiThreadPso p3=new MultiThreadPso();
 77 | 		try 
 78 | 		{
 79 | 			p1.t.join();
 80 | 			p2.t.join();
 81 | 			p3.t.join();
 82 | 	    }
 83 | 	    catch (Exception ex) {}
 84 | 		p1.disp();
 85 | 		p2.disp();
 86 | 		p3.disp();
 87 | 		
 88 | 	}
 89 | 
 90 | 	public static void ParallelPso_driver(ParallelPso_Server p,int no_of_clients)
 91 | 	{
 92 | 		
 93 | 		
 94 | 		ParallelPso_Client c[]=new ParallelPso_Client[no_of_clients];
 95 | 		p.init();
 96 | 		
 97 | 		
 98 | 		for (int i = 0; i<no_of_clients; i++)
 99 | 		{
100 | 				c[i]=new ParallelPso_Client();
101 | 				c[i].init();
102 | 				
103 | 		}
104 | 		
105 | 		
106 | 		p.writeInitData();
107 | 	
108 | 		for (int i = 0; i<no_of_clients; i++)
109 | 			c[i].t.start();
110 | 		p.interactWithClient();
111 | 		
112 | 		for (int i = 0; i<no_of_clients; i++)
113 | 		{
114 | 			try 
115 | 			{
116 | 				c[i].t.join();	
117 | 		    }
118 | 		    catch (Exception ex) {}
119 | 		    
120 | 		}
121 | 		p.disp();
122 | 		
123 | 	}
124 | 		
125 | }


--------------------------------------------------------------------------------
/SAnnealingPso.java:
--------------------------------------------------------------------------------
  1 | package PSO;
  2 | import java.io.*;
  3 | import java.util.*;
  4 | 
  5 | class SAnnealingPso extends Pso
  6 | {
  7 | 	
  8 | 	boolean need_sa;
  9 | 	int obj;
 10 | 	
 11 | 	public double update(double w)
 12 | 	{
 13 | 		return ((.9-.4)*cur_iter_no)/max_iterate;
 14 | 	}
 15 | 	public void fit_calc(int index)
 16 | 	{
 17 | 		
 18 | 		int i,j,pos=0;
 19 | 		TaskInfo ti;
 20 | 		int maxspan=0;
 21 |   		double obj=0;
 22 |   		int tim[]=new int[no_of_processors];
 23 |   		LinkedList proc_assign[]=new LinkedList[no_of_processors];
 24 |    		for(i=0;i<no_of_processors;i++)
 25 | 			proc_assign[i]=new LinkedList();
 26 | 		transform_particle(proc_assign,index);   		
 27 |    		for(i=0;i<no_of_processors;i++)
 28 |   		{
 29 |   			for(j=0;j<proc_assign[i].size();j++)
 30 |   			{
 31 |   				pos=((Int)proc_assign[i].get(j)).val;
 32 |   				ti=(TaskInfo)tasks.get(pos);
 33 |   				tim[i]+=ti.exec_t[i];
 34 |   			}
 35 |   			if(maxspan<tim[i])
 36 |   				maxspan=tim[i];
 37 |   		}
 38 |   		for ( i = 0; i<no_of_processors; i++)
 39 |   			obj+=(double)tim[i]/maxspan;
 40 |   		if(gbestv<obj)
 41 |   		{
 42 |   			for(i=0;i<no_of_tasks;i++)
 43 |   					((Int)pbest[index].get(i)).val=((Int)gbest.get(i)).val=((TaskInfo)tasks.get(i)).allocation[index];
 44 |   			pbestv[index]=gbestv=obj;
 45 |   			gbest_iter_no=cur_iter_no;
 46 |   			
 47 |   		}
 48 |   		else if(pbestv[index]<obj)
 49 |   		{
 50 |   			for(i=0;i<no_of_tasks;i++)
 51 |   				((Int)pbest[index].get(i)).val=((TaskInfo)tasks.get(i)).allocation[index];
 52 |   			pbestv[index]=obj;
 53 |   			
 54 |   		}
 55 |   		
 56 | 	}
 57 | 	
 58 | 	public void doSimulatedAnnealing(int index)
 59 | 	{
 60 | 		int random_pos1=((int)(Math.random()*no_of_tasks))%no_of_tasks;
 61 | 		int random_pos2;
 62 | 		double T=0.6;
 63 | 		double prob_fn;
 64 | 		
 65 | 		if(random_pos1==no_of_tasks-1)	
 66 | 			random_pos2=random_pos1-1;
 67 | 		else
 68 | 			random_pos2=random_pos1+1;
 69 | 			
 70 | 		prob_fn=Math.exp((gbestv-obj)/T);
 71 | 		
 72 | 		if(prob_fn>0.5)
 73 | 		{
 74 | 			int hold=((TaskInfo)tasks.get(random_pos1)).allocation[index];
 75 | 			((TaskInfo)tasks.get(random_pos1)).allocation[index]=((TaskInfo)tasks.get(random_pos2)).allocation[index];
 76 | 			((TaskInfo)tasks.get(random_pos2)).allocation[index]=hold;	
 77 | 			fit_calc(index);
 78 | 		}
 79 | 	}
 80 | 	public void iterate()
 81 | 	{
 82 | 		double w=0.9;
 83 | 		LinkedList vel[]=new LinkedList[no_of_particles];
 84 | 		Doubl v;
 85 | 		int i,j,k,pb,gb,pc;
 86 | 		
 87 | 		for(i=0;i<no_of_particles;i++)
 88 | 		{
 89 | 			vel[i]=new LinkedList();
 90 | 			for(j=0;j<no_of_tasks;j++)
 91 | 			{
 92 | 				vel[i].add(new Doubl(0.0));
 93 | 			}
 94 | 		}
 95 | 		for(cur_iter_no=1;cur_iter_no<=max_iterate;cur_iter_no++)
 96 | 		{
 97 | 			for(j=0;j<no_of_particles;j++)
 98 | 			{
 99 | 				for(k=0;k<no_of_tasks;k++)
100 |     			{
101 | 					v=(Doubl)vel[j].get(k);
102 | 					pb=((Int)pbest[j].get(k)).val;
103 | 					gb=((Int)gbest.get(k)).val;
104 | 					pc=((TaskInfo)tasks.get(k)).allocation[j];
105 | 					v.val=w*v.val+2*(Math.random()*(pb-pc)+Math.random()*(gb-pc));
106 | 					((TaskInfo)tasks.get(k)).allocation[j]=(int)(Math.abs(pc+v.val+0.5)%no_of_processors)+1;
107 | 				}
108 | 				fit_calc(j);
109 | 				if(need_sa==true)
110 | 				doSimulatedAnnealing(j);
111 | 			}
112 | 		w=update(w);
113 | 		}
114 | 	}
115 | 
116 | }
117 | 


--------------------------------------------------------------------------------
/ParallelPso_Server.java:
--------------------------------------------------------------------------------
  1 | package PSO;
  2 | import java.io.*;
  3 | import java.util.*;
  4 | import java.net.*;
  5 | 
  6 | class ObjToClient implements Serializable
  7 | {
  8 | 	int no_of_processors;
  9 | 	int max_iterate;
 10 | 	int no_of_tasks;
 11 | 	int no_of_particles;
 12 | 	LinkedList tasks;
 13 | 	LinkedList gbest;
 14 | 	double gbestv=0;
 15 | 	LinkedList pbest[];
 16 | 	double pbestv[];
 17 | 	
 18 | 	ObjToClient(int p,int t,int pa,int mi,LinkedList ll,LinkedList gb,LinkedList pb[],double gv,double pv[])
 19 | 	{
 20 | 		max_iterate=mi;
 21 | 		no_of_processors=p;
 22 | 		no_of_tasks=t;
 23 | 		no_of_particles=pa;
 24 | 		tasks=new LinkedList(ll);
 25 | 		pbest=pb;
 26 | 		gbest=gb;
 27 | 		gbestv=gv;
 28 | 		pbestv=pv;
 29 | 	}
 30 | }
 31 | 
 32 | public class ParallelPso_Server extends Pso
 33 | {
 34 | 	
 35 | 	Socket client[];
 36 | 	ServerSocket ser;
 37 | 	ObjectOutputStream oos[];
 38 | 	ObjectInputStream ois[];
 39 | 		
 40 | 	
 41 | 
 42 | 		
 43 | 	public ParallelPso_Server(int noc)
 44 | 	{
 45 | 		try
 46 | 		{
 47 | 			bInit();
 48 | 		 	ser=new ServerSocket(2000);
 49 | 			client=new Socket[noc];
 50 | 			new Server(client,ser);
 51 | 		}catch(Exception e){System.out.println (e);}
 52 | 	}
 53 | 	
 54 | 	public void init()
 55 | 	{
 56 | 		super.init();
 57 | 		generate();
 58 | 	}
 59 | 	
 60 | 	public void writeInitData()
 61 | 	{
 62 | 		ObjToClient obc;
 63 | 		oos=new ObjectOutputStream[client.length];
 64 | 		ois=new ObjectInputStream[client.length];
 65 | 		try 
 66 | 		{
 67 | 			obc=new ObjToClient(no_of_processors,no_of_tasks,no_of_particles,max_iterate,tasks,gbest,pbest,gbestv,pbestv);
 68 |  			for (int i = 0; i<client.length; i++)	
 69 | 			{
 70 | 			    
 71 | 		 		oos[i]=new ObjectOutputStream(client[i].getOutputStream());
 72 | 				oos[i].writeObject(obc);
 73 | 			}
 74 |  			
 75 | 	    }
 76 | 	    catch (Exception ex) {ex.printStackTrace();System.exit(0);}
 77 | 	}
 78 | 	public void interactWithClient()
 79 | 	{
 80 | 		ObjToClient obc;
 81 | 		GbestInfo obs;
 82 | 		int i;
 83 | 		try 
 84 |  		{
 85 |  		ois=new ObjectInputStream[client.length];
 86 | 		
 87 | 		for (i = 0; i<client.length; i++)
 88 | 			ois[i]=new ObjectInputStream(client[i].getInputStream());
 89 | 		
 90 | 		for (int j = 1; j<=max_iterate;j++)
 91 | 			{
 92 | 			
 93 | 					for(i=0;i<client.length;i++)
 94 |  					{
 95 |  						obs=(GbestInfo)ois[i].readObject();
 96 |  						if(gbestv<obs.cost)
 97 |  						{
 98 |  							gbestv=obs.cost;
 99 |  							gbest=obs.gb;	
100 |  							gbest_iter_no=j;
101 |  						}
102 |  					}
103 | 				
104 | 					obs=new GbestInfo(gbest,gbestv);
105 | 					for( i=0;i<client.length;i++)
106 |  					{
107 |  						oos[i].writeObject(obs);
108 |  					}
109 |  			
110 | 				
111 | 			}
112 | 		ser.close();	
113 |  		}catch (Exception ex) {System.out.println (ex);}		
114 | 	}
115 | }
116 | 
117 | class Server implements Runnable
118 | {
119 | 	Socket s[];
120 | 	ServerSocket ser;
121 | 	Thread t;
122 | 	Server(Socket s[],ServerSocket ser)	
123 | 	{
124 | 		
125 | 		this.s=s;
126 | 		this.ser=ser;
127 | 		t=new Thread(this);
128 | 		t.start();
129 | 	}
130 | 	
131 | 	public void run()
132 | 	{
133 | 		try 
134 | 		{
135 | 			for (int i = 0; i<s.length; i++)
136 | 			{
137 | 			
138 | 					s[i]=ser.accept();
139 | 			}		
140 | 		
141 | 	    }catch (Exception ex) {System.out.println (ex);}
142 | 	}
143 | }
144 | 
145 | 
146 | 
147 | 


--------------------------------------------------------------------------------
/Pso.java:
--------------------------------------------------------------------------------
  1 | package PSO;
  2 | import java.io.*;
  3 | import java.util.*;
  4 | class Int implements Serializable
  5 | {
  6 | 	public int val;
  7 | 	Int(int v)
  8 | 	{
  9 | 		val=v;
 10 | 	}
 11 | }
 12 | class Doubl implements Serializable
 13 | {
 14 | 	public double val;
 15 | 	Doubl(double v)
 16 | 	{
 17 | 		val=v;
 18 | 	}
 19 | }
 20 | 
 21 | public class Pso
 22 | {
 23 | 	int max_iterate;
 24 | 	int gbest_iter_no; 
 25 | 	int cur_iter_no;
 26 | 	int no_of_processors;
 27 | 	int no_of_tasks;
 28 | 	int no_of_particles;
 29 | 	LinkedList tasks;
 30 | 	LinkedList pbest[];
 31 | 	double pbestv[];
 32 | 	LinkedList gbest;
 33 | 	double gbestv=0;
 34 | 	
 35 | 	BufferedReader in;		
 36 | 	public void bInit()
 37 | 	{
 38 | 		try
 39 | 		{
 40 | 		in=new BufferedReader(new FileReader("Basic_data.txt"));
 41 | 		TaskInfo.no_of_processors=no_of_processors=Integer.parseInt(in.readLine());
 42 | 		no_of_tasks=Integer.parseInt(in.readLine());
 43 | 		TaskInfo.no_of_particles=no_of_particles=Integer.parseInt(in.readLine());
 44 | 		max_iterate=Integer.parseInt(in.readLine());
 45 | 		gbest=new LinkedList();
 46 | 		pbest=new LinkedList[no_of_particles];
 47 | 		pbestv=new double[no_of_particles];
 48 | 		tasks=new LinkedList();
 49 | 		
 50 | 		}catch(Exception e){}
 51 | 	}
 52 | 	
 53 | 	public void init()
 54 | 	{
 55 | 		
 56 | 		TaskInfo task;
 57 | 		int i,j;
 58 | 		for(i=0;i<no_of_particles;i++)
 59 | 		{
 60 | 			pbest[i]=new LinkedList();
 61 | 			for(j=0;j<no_of_tasks;j++)
 62 | 				pbest[i].add(new Int(0));
 63 | 		}
 64 | 		TaskInfo.init();
 65 | 		for( i=0;i<no_of_tasks;i++)
 66 | 		{
 67 | 			task=new TaskInfo();
 68 | 			task.set();
 69 | 			tasks.add(task);
 70 | 			gbest.add(new Int(0));
 71 | 		}
 72 | 		TaskInfo.close();
 73 | 		
 74 | 	}
 75 | 	public boolean unique(int index)
 76 | 	{
 77 | 		int i,j;
 78 | 		for( i=0;i<index;i++)
 79 | 		{
 80 | 			for(j=0;j<no_of_tasks;j++)
 81 | 			{
 82 | 					if(((TaskInfo)tasks.get(j)).allocation[index]!=((TaskInfo)tasks.get(j)).allocation[i])
 83 | 					break;
 84 | 					
 85 | 			}
 86 | 			if(j==no_of_tasks)
 87 |    				return false;
 88 | 		}
 89 | 	return true;
 90 | 	}
 91 | 	public void transform_particle(LinkedList proc_assign[],int index)
 92 | 	{
 93 | 		int t;
 94 | 		for(int i=0;i<no_of_tasks;i++)
 95 | 		{
 96 | 			t=((TaskInfo)tasks.get(i)).allocation[index]-1;
 97 | 					if(t<0)t=0;
 98 | 					proc_assign[t].add(new Int(i));
 99 | 		}
100 | 	}
101 | 	public void fit_calc(int index)
102 | 	{
103 | 		
104 | 		int i,j,pos=0;
105 | 		TaskInfo ti;
106 | 		int maxspan=0;
107 |   		double obj=0;
108 |   		int tim[]=new int[no_of_processors];
109 |   		LinkedList proc_assign[]=new LinkedList[no_of_processors];
110 |    		for(i=0;i<no_of_processors;i++)
111 | 			proc_assign[i]=new LinkedList();
112 | 		transform_particle(proc_assign,index);   		
113 |    		for(i=0;i<no_of_processors;i++)
114 |   		{
115 |   			for(j=0;j<proc_assign[i].size();j++)
116 |   			{
117 |   				pos=((Int)proc_assign[i].get(j)).val;
118 |   				ti=(TaskInfo)tasks.get(pos);
119 |   				tim[i]+=ti.exec_t[i];
120 |   			}
121 |   			if(maxspan<tim[i])
122 |   				maxspan=tim[i];
123 |   		}
124 |   		for ( i = 0; i<no_of_processors; i++)
125 |   			obj+=(double)tim[i]/maxspan;
126 |   		if(gbestv<obj)
127 |   		{
128 |   			for(i=0;i<no_of_tasks;i++)
129 |   					((Int)pbest[index].get(i)).val=((Int)gbest.get(i)).val=((TaskInfo)tasks.get(i)).allocation[index];
130 |   			pbestv[index]=gbestv=obj;
131 |   			gbest_iter_no=cur_iter_no;
132 |   			
133 |   		}
134 |   		else if(pbestv[index]<obj)
135 |   		{
136 |   			for(i=0;i<no_of_tasks;i++)
137 |   				((Int)pbest[index].get(i)).val=((TaskInfo)tasks.get(i)).allocation[index];
138 |   			pbestv[index]=obj;
139 |   			
140 |   		}
141 |   		
142 | 	}
143 | 	public void generate()
144 | 	{
145 | 		
146 | 		 for(int i=0;i<no_of_particles;i++)
147 | 		 {
148 | 		 	
149 | 		 	do
150 |   			{
151 |   				form_particle(i);
152 |   			}while(!unique(i));
153 |   			fit_calc(i);
154 |  		}
155 | 	}
156 | 	
157 | 	private void form_particle(int index)
158 | 	{
159 | 		Random rand=new Random();
160 | 		int temp,i;
161 | 		for( i=1;i<=no_of_processors;i++)
162 | 		{
163 | 			do
164 | 			{
165 | 				temp=rand.nextInt(no_of_tasks);
166 | 			}while(((TaskInfo)tasks.get(temp)).allocation[index]!=0);
167 | 			((TaskInfo)tasks.get(temp)).allocation[index]=i;
168 | 		}
169 | 		
170 | 		for(i=0;i<no_of_tasks;i++)
171 | 		{
172 | 			if(((TaskInfo)tasks.get(i)).allocation[index]==0)
173 | 				((TaskInfo)tasks.get(i)).allocation[index]=rand.nextInt(no_of_processors)+1;
174 | 		}
175 | 	}
176 | 	public double update(double w)
177 | 	{
178 | 		return w;
179 | 	}
180 | 	public void iterate()
181 | 	{
182 | 		double w=0.9;
183 | 		LinkedList vel[]=new LinkedList[no_of_particles];
184 | 		Doubl v;
185 | 		int i,j,k,pb,gb,pc;
186 | 		
187 | 		for(i=0;i<no_of_particles;i++)
188 | 		{
189 | 			vel[i]=new LinkedList();
190 | 			for(j=0;j<no_of_tasks;j++)
191 | 			{
192 | 				vel[i].add(new Doubl(0.0));
193 | 			}
194 | 		}
195 | 		for(cur_iter_no=1;cur_iter_no<=max_iterate;cur_iter_no++)
196 | 		{
197 | 			for(j=0;j<no_of_particles;j++)
198 | 			{
199 | 				for(k=0;k<no_of_tasks;k++)
200 |     			{
201 | 					v=(Doubl)vel[j].get(k);
202 | 					pb=((Int)pbest[j].get(k)).val;
203 | 					gb=((Int)gbest.get(k)).val;
204 | 					pc=((TaskInfo)tasks.get(k)).allocation[j];
205 | 					v.val=w*v.val+2*(Math.random()*(pb-pc)+Math.random()*(gb-pc));
206 | 					((TaskInfo)tasks.get(k)).allocation[j]=(int)(Math.abs(pc+v.val+0.5)%no_of_processors)+1;
207 | 				}
208 | 				fit_calc(j);
209 | 			}
210 | 		w=update(w);
211 | 		}
212 | 	}
213 | 	public void disp()
214 | 	{
215 | 		System.out.println ("Best Allocation : ");
216 | 		for(int i=0;i<no_of_tasks;i++)
217 | 			System.out.print(((Int)gbest.get(i)).val+" ");
218 | 		System.out.println("\nCost : "+gbestv+"\nNo. of Iterations : "+gbest_iter_no);
219 | 	
220 | 		
221 | 	}
222 | }
223 | 
224 | 


--------------------------------------------------------------------------------