package net.yacy.kelondro.order; import java.util.ArrayList; import java.util.Random; import java.util.concurrent.BlockingQueue; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.locks.AbstractQueuedSynchronizer; /** * an abstraction of the quicksort from the java.util.Array class * @author admin * */ public class Array { private final static int SORT_JOBS = Runtime.getRuntime().availableProcessors() + 1; @SuppressWarnings({ "unchecked", "rawtypes" }) private final static SortJob POISON_JOB_WORKER = new SortJob(null, 0, 0, 0, 0, null); @SuppressWarnings({ "unchecked", "rawtypes" }) private final static BlockingQueue> sortJobs = new LinkedBlockingQueue(); static { for (int i = 0; i < SORT_JOBS; i++) { new SortJobWorker().start(); } } public static void terminate() { for (int i = 0; i < SORT_JOBS; i++) { try { sortJobs.put(POISON_JOB_WORKER); } catch (final InterruptedException e) {} } } private static class SortJobWorker extends Thread { public void run() { SortJob job; try { while ((job = sortJobs.take()) != POISON_JOB_WORKER) { sort(job, job.depth < 8); job.latch.countDown(); } } catch (final InterruptedException e) { } } } public static final class UpDownLatch extends AbstractQueuedSynchronizer { private static final long serialVersionUID = 1L; public UpDownLatch(final int count) { setState(count); } public int getCount() { return getState(); } public int tryAcquireShared(final int acquires) { return getState() == 0? 1 : -1; } public boolean tryReleaseShared(final int releases) { // Decrement count; signal when transition to zero for (;;) { final int c = getState(); if (c == 0) return false; final int nextc = c-1; if (compareAndSetState(c, nextc)) return nextc == 0; } } public void countUp() { for (;;) { final int c = getState(); if (compareAndSetState(c, c + 1)) return; } } public void countDown() { releaseShared(1); } public void await() throws InterruptedException { acquireSharedInterruptibly(1); } } public static void sort(final Sortable x) { UpDownLatch latch; final boolean threaded = false;//x.size() > 100000; sort(new SortJob(x, 0, x.size(), x.buffer(), 0, latch = new UpDownLatch(0)), threaded); //for (int i = 0; i < 100; i++) {System.out.println("latch = " + latch.getCount());try {Thread.sleep(10);} catch (final InterruptedException e) {}} if (threaded) try {latch.await();} catch (final InterruptedException e) {} } private static class SortJob { final Sortable x; final int o; final int l; final A f; final int depth; UpDownLatch latch; public SortJob(final Sortable x, final int o, final int l, final A f, final int depth, final UpDownLatch latch) { this.x = x; this.o = o; this.l = l; this.f = f; this.depth = depth; this.latch = latch; } } private static void sort(final SortJob job, final boolean threaded) { // in case of small arrays we do not need a quicksort if (job.l < 7) { for (int i = job.o; i < job.l + job.o; i++) { for (int j = i; j > job.o && job.x.compare(job.x.get(j, false), job.x.get(j - 1, false)) < 0; j--) job.x.swap(j, j - 1, job.f); } return; } // find the pivot element int m = job.o + (job.l >> 1); if (job.l > 7) { int k = job.o; int n = job.o + job.l - 1; if (job.l > 40) { final int s = job.l / 8; k = med3(job.x, k , k + s, k + 2 * s); m = med3(job.x, m - s , m , m + s ); n = med3(job.x, n - 2 * s, n - s, n ); } m = med3(job.x, k, m, n); } final A p = job.x.get(m, true); // do a partitioning of the sequence int a = job.o, b = a, c = job.o + job.l - 1, d = c; A _v; while (true) { while (c >= b && job.x.compare(p, (_v = job.x.get(b, false))) >= 0) { if (job.x.compare(_v, p) == 0) job.x.swap(a++, b, job.f); b++; } while (c >= b && job.x.compare((_v = job.x.get(c, false)), p) >= 0) { if (job.x.compare(_v, p) == 0) job.x.swap(c, d--, job.f); c--; } if (b > c) break; job.x.swap(b++, c--, job.f); } // swap all int s; final int n = job.o + job.l; s = Math.min(a - job.o, b - a ); swap(job.x, job.o, b - s, s, job.f); s = Math.min(d - c, n - d - 1); swap(job.x, b, n - s, s, job.f); // recursively sort partitions if ((s = b - a) > 1) { final SortJob nextJob = new SortJob(job.x, job.o, s, job.f, job.depth + 1, job.latch); if (threaded) try { job.latch.countUp(); sortJobs.put(nextJob); } catch (final InterruptedException e) { } else { sort(nextJob, threaded); } } if ((s = d - c) > 1) { final SortJob nextJob = new SortJob(job.x, n - s, s, job.x.buffer(), job.depth + 1, job.latch); if (threaded) try { job.latch.countUp(); sortJobs.put(nextJob); } catch (final InterruptedException e) { } else { sort(nextJob, threaded); } } } private static void swap(final Sortable x, int a, int b, final int n, final A buffer) { if (n == 1) { x.swap(a, b, buffer); } else { for (int i = 0; i < n; i++, a++, b++) x.swap(a, b, buffer); } } private static int med3(final Sortable x, final int a, final int b, final int c) { final A _a = x.get(a, false); final A _b = x.get(b, false); final A _c = x.get(c, false); return (x.compare(_a, _b) < 0 ? (x.compare(_b, _c) < 0 ? b : x.compare(_a, _c) < 0 ? c : a) : (x.compare(_c, _b) < 0 ? b : x.compare(_c, _a) < 0 ? c : a)); } private static class P extends ArrayList implements Sortable { private static final long serialVersionUID = 1L; public P() { super(); } @Override public int compare(final Integer o1, final Integer o2) { return o1.compareTo(o2); } @Override public Integer buffer() { return new Integer(0); } @Override public void swap(final int i, final int j, Integer buffer) { buffer = get(i); set(i, get(j)); set(j, buffer); } @Override public void delete(final int i) { this.remove(i); } @Override public Integer get(final int i, final boolean clone) { return get(i); } } public static void uniq(final Sortable x) { if (x.size() < 2) return; int i = x.size() - 1; A a = x.get(i--, true), b; while (i >= 0) { b = x.get(i, true); if (x.compare(a, b) == 0) { x.delete(i); } else { a = b; } i--; } } public static void main(final String[] args) { final int count = 1000000; final P test = new P(); Random r = new Random(0); for (int i = 0; i < count; i++) { test.add(r.nextInt()); } r = new Random(0); for (int i = 0; i < count; i++) { test.add(r.nextInt()); } final long t0 = System.currentTimeMillis(); sort(test); final long t1 = System.currentTimeMillis(); System.out.println("sort = " + (t1 - t0) + "ms"); //uniq(test); final long t2 = System.currentTimeMillis(); System.out.println("uniq = " + (t2 - t1) + "ms"); System.out.println("result: " + test.size()); terminate(); } }