Art of Multiprocessor Programming 答案 ch16

package p187;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class ArraySum 
{
	static ExecutorService Execs = Executors.newCachedThreadPool();
	
	static int Add(int[] data) throws ExecutionException, InterruptedException
	{
		Result rc = new Result(0);
		Future future = Execs.submit(new AddClass(data, 0, data.length - 1, rc));
		future.get();
		
		return rc.get();
	}
	
	static class Result
	{
		private int val;
		
		public Result(int val)
		{
			this.val = val;
		}
		
		public int get()
		{
			return this.val;
		}
		
		public void set(int val)
		{
			this.val = val;
		}
	}
	
	static class AddClass implements Runnable
	{
		int[] data;
		Result rc;
		int lIndex;
		int rIndex;
		
		
		public AddClass(int[] data, int lIndex, int rIndex, Result rc)
		{
			this.data = data;
			this.rc = rc;
			this.lIndex = lIndex;
			this.rIndex = rIndex;
		}
		
		public void run()
		{
			try
			{
				if(rIndex < lIndex)
				{
					rc.set(0);
				}else if(lIndex == rIndex)
				{
					rc.set(data[lIndex]);
				}else
				{
					Result leftRc = new Result(0);
					Result rightRc = new Result(0);
					int mid = (lIndex + rIndex) / 2;
					
					Future lf = Execs.submit(new AddClass(data, lIndex, mid, leftRc));
					Future rf = Execs.submit(new AddClass(data, mid + 1, rIndex, rightRc));
					
					lf.get();
					rf.get();
					
					rc.set(leftRc.get() + rightRc.get());
				}
				
			}catch(Exception e)
			{
				e.printStackTrace();
			}
			
		}
	}

}

package p189;

public class Matrix
{
	private T[][] vcs;
	private final int sRow;
	private final int eRow;
	private final int sCol;
	private final int eCol;
	private final int rLen;
	private final int cLen;
	
	@SuppressWarnings("unchecked")
	public Matrix(int rowLen, int colLen)
	{
		this.vcs = (T[][]) new Object[rowLen][];
		for(int i = 0; i < rowLen; i ++)
		{
			vcs[i] = (T[]) new Object[colLen];
		}
		
		sRow = 0;
		eRow = rowLen - 1;
		sCol = 0;
		eCol = colLen - 1;
		rLen = rowLen;
		cLen = colLen;
	}
	
	public Matrix(T[][] vcs, int sRow, int eRow, int sCol, int eCol)
	{
		this.vcs = vcs;
		this.sRow = sRow;
		this.eRow = eRow;
		this.sCol = sCol;
		this.eCol = eCol;
		this.rLen = eRow - sRow + 1;
		this.cLen = eCol - sCol + 1;
	}
	
	public void set(int row, int col, T val) throws Exception
	{
		if((sRow + row) > eRow) throw new Exception("Invalid row ");
		if((sCol + col) > eCol) throw new Exception("Invalid col");
		vcs[sRow + row][sCol + col] = val;
	}
	
	public T get(int row, int col) throws Exception
	{
		if((sRow + row) > eRow) throw new Exception("Invalid row ");
		if((sCol + col) > eCol) throw new Exception("Invalid col");
		return vcs[sRow + row][sCol + col];
	}
	
	public int getRowLength()
	{
		return rLen;
	}
	
	public int getColLength()
	{
		return cLen;
	}
	
	@SuppressWarnings("unchecked")
	public Matrix[][] split()
	{
		int mRow = (sRow + eRow) /2;
		int mCol = (sCol + eCol) / 2;
		
		Matrix[][] rcs = (Matrix[][]) new Matrix[2][];
		
		for(int i = 0; i < rcs.length; i ++)
		{
			rcs[i] = (Matrix[]) new Matrix[2];
		}
		
		rcs[0][0] = new Matrix(vcs, sRow, mRow, sCol, mCol);
		
		if(sCol == eCol)
		{
			rcs[0][1] = new Matrix(vcs, 0, -1, 0, -1);
			rcs[1][1] = new Matrix(vcs, 0, -1, 0, -1);
		}else
		{
			rcs[0][1] = new Matrix(vcs, sRow, mRow, mCol + 1, eCol);
		}
		
		if(sRow == eRow)
		{
			rcs[1][0] = new Matrix(vcs, 0, -1, 0, -1);
			rcs[1][1] = new Matrix(vcs, 0, -1, 0, -1);
		}else
		{
			rcs[1][0] = new Matrix(vcs, mRow + 1, eRow, sCol, mCol);
			rcs[1][1] = new Matrix(vcs, mRow + 1, eRow, mCol + 1, eCol);
		}
		return rcs;
	}
	
	
	public String toString()
	{
		if(rLen <= 0 || cLen <= 0)
		{
			return "Empty";
		}
		
		StringBuilder str = new StringBuilder();
		
		for(int i = sRow; i <= eRow; i ++)
		{
			for(int j = sCol; j <= eCol; j ++)
			{
				str.append(vcs[i][j]);
				str.append(", ");
			}
			str.append("\n");
		}
		
		return str.toString();
	}
	
	public static void main(String[] args)
	{
		Integer[][] data = new Integer[8][];
		for(int i = 0; i < data.length; i ++)
		{
			data[i] = new Integer[8];
		}
		
		for(int i = 0; i < data.length; i ++)
		{
			for(int j = 0; j < data[i].length; j ++)
			{
				data[i][j] = i * 10 + j;
			}
		}
		
		Matrix m = new Matrix(data, 0, data.length - 1, 0, data[0].length - 1);
		
		while(m.getRowLength() > 0)
		{
			System.out.println(m);
			
			Matrix[][] subMs = m.split();
			
			for(int i = 0; i < subMs.length; i ++)
			{
				for(int j = 0; j < subMs[i].length; j ++)
				{
					System.out.println(subMs[i][j]);
				}
			}
			
			m = subMs[1][1];
		}
	}
}

package p190;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

public class PolyOp 
{
	static ExecutorService Execs = Executors.newCachedThreadPool();
	
	static Long Op(int x, Polynomial leftPrefix, Polynomial rightPrefix, OP op) throws ExecutionException, InterruptedException
	{
		long xs[] = new long[leftPrefix.getDegree() * 2];
		long sum = 1;
		for(int i = 0; i < xs.length; i ++)
		{
			xs[i] = sum;
			sum *= x;
		}
		
		Result rc = new Result((long)0);
		Future f = Execs.submit(new OpClass(leftPrefix, rightPrefix, xs, rc, op));
		f.get();
		
		return rc.get();
	}
	
	static class Result
	{
		private T val;
		
		public Result(T val)
		{
			this.val = val;
		}
		public T get()
		{
			return this.val;
		}
		public void set(T val)
		{
			this.val = val;
		}
	}
	
	static enum OP 
	{
		ADD,
		MUL,
	};
	
	static class OpClass implements Runnable
	{
		private Polynomial leftPrefix;
		private Polynomial rightPrefix;
		private final long x[];
		private Result rc;
		private final OP op;
		
		public OpClass(Polynomial leftPrefix, Polynomial rightPrefix, long x[], Result rc, OP op)
		{
			this.leftPrefix = leftPrefix;
			this.rightPrefix = rightPrefix;
			this.x = x;
			this.rc = rc;
			this.op = op;
		}
		
		private void add()
		{
			try
			{
				if(leftPrefix.getDegree() == 1)
				{
					rc.set(new Long(leftPrefix.get(0) + rightPrefix.get(0)));
				}else
				{
					Result fRc = new Result((long)0);
					Result lRc = new Result((long)0);
					
					Polynomial[] leftPs = leftPrefix.split();
					Polynomial[] rightPs = rightPrefix.split();
					
					Future ff = Execs.submit(new OpClass(leftPs[0], rightPs[0], x, fRc, op));
					Future lf = Execs.submit(new OpClass(leftPs[1], rightPs[1], x, lRc, op));
					
					ff.get();
					lf.get();
					
					long result = fRc.get() + lRc.get() * x[leftPs[0].getDegree()];
					rc.set(result);
				}
			}catch(Exception e)
			{
				e.printStackTrace();
			}		
		}
		
		private void mul()
		{
			try
			{
				if(leftPrefix.getDegree() == 1)
				{
					rc.set(new Long(leftPrefix.get(0) * rightPrefix.get(0)));
				}else
				{
					Result fRc = new Result((long)0);
					Result lRc = new Result((long)0);
					Result mRc1 = new Result((long)0);
					Result mRc2 = new Result((long)0);
										
					Polynomial[] leftPs = leftPrefix.split();
					Polynomial[] rightPs = rightPrefix.split();
					
					Future ff = Execs.submit(new OpClass(leftPs[0], rightPs[0], x, fRc, op));
					Future fm1 = Execs.submit(new OpClass(leftPs[0], rightPs[1], x, mRc1, op));
					Future fm2 = Execs.submit(new OpClass(leftPs[1], rightPs[0], x, mRc2, op));
					Future fr = Execs.submit(new OpClass(leftPs[1], rightPs[1], x, lRc, op));
					
					ff.get();
					fr.get();
					fm1.get();
					fm2.get();
					
					long result = fRc.get() + (lRc.get() * x[leftPrefix.getDegree()]) + (mRc1.get() + mRc2.get()) * x[leftPs[0].getDegree()];
					rc.set(result);
				}
				
			}catch(Exception e)
			{
				e.printStackTrace();
			}				
		}
		
		public void run()
		{
			switch(op)
			{
			case ADD:
				add();
				break;
			case MUL:
				mul();
				break;
			default:
				System.out.println("Invalid op");
				break;
			}
		}
	}
	
	public static void main(String[] args)
	{
		int degree = 4;
		Polynomial left = new Polynomial(degree);
		Polynomial right = new Polynomial(degree);
		
		for(int i = 0; i < left.getDegree(); i ++)
		{
			left.set(i, 1);
			right.set(i, 1);
		}
		
		try
		{
			long rc = PolyOp.Op(2, left, right, PolyOp.OP.MUL);
			System.out.println("Get  " + rc);
		}catch(Exception e)
		{
			e.printStackTrace();
		}
	}
}

public Runnable popTop()
{
    while(true)
    {
        int[] stamp = new int[1];
        int oldTop = top.get(stamp);
        int newTop = oldTop + 1;
        int oldStamp = stamp[0];
        int newStamp = oldStamp + 1;
        
        if(bottom <= oldTop)
        {
            return null;
        }
        
        Runnable r = task[oldTop];
        if(top.compareAndSet(oldTop, newTop, oldStamp, newStamp))
        {
            return r;
        }
    }
    
    //impossible
    return null;
}