public static void initialbuild() throws IOException, InterruptedException {
System.out.println("building an empty map");
long start = System.currentTimeMillis();
Thread t1 =
new Thread("test 1") {
public void run() {
populate(1);
}
};
t1.start();
Thread t2 =
new Thread("test 2") {
public void run() {
populate(2);
}
};
t2.start();
Thread t3 =
new Thread("test 3") {
public void run() {
populate(3);
}
};
t3.start();
populate(0);
t1.join();
t2.join();
t3.join();
long now = System.currentTimeMillis();
System.out.println(builder);
System.out.println("Time taken to insert all entries " + ((now - start) / 1000.0) + " seconds");
}
public static void main(String[] args) throws Exception {
int minTokenCount = 5;
File corpusFile = new File(args[0]);
CharSequence[] articleTexts = LdaWormbase.readCorpus(corpusFile);
SymbolTable symbolTable = new MapSymbolTable();
TokenizerFactory tokenizerFactory = LdaWormbase.WORMBASE_TOKENIZER_FACTORY;
int[][] docTokens =
LatentDirichletAllocation.tokenizeDocuments(
articleTexts, tokenizerFactory, symbolTable, minTokenCount);
LdaRunnable runnable1 =
new LdaRunnable(docTokens, new LdaReportingHandler(symbolTable), new Random());
LdaRunnable runnable2 =
new LdaRunnable(docTokens, new LdaReportingHandler(symbolTable), new Random());
Thread thread1 = new Thread(runnable1);
Thread thread2 = new Thread(runnable2);
thread1.start();
thread2.start();
thread1.join();
thread2.join();
LatentDirichletAllocation lda0 = runnable1.mLda;
LatentDirichletAllocation lda1 = runnable2.mLda;
System.out.println("\nComputing Greedy Aligned Symmetrized KL Divergences");
double[] scores = similarity(lda0, lda1);
for (int i = 0; i < scores.length; ++i) System.out.printf("%4d %15.3f\n", i, scores[i]);
}
public static void main(String[] args) throws IOException, InterruptedException {
long start = System.currentTimeMillis();
initialbuild();
System.out.println("Start highwatermark " + Highwatermark.get());
for (int i = 0; i < 10; i++) {
Thread t1 =
new Thread("test 1") {
public void run() {
_test();
}
};
Thread t2 =
new Thread("test 2") {
public void run() {
_test();
}
};
Thread t3 =
new Thread("test 3") {
public void run() {
_test();
}
};
t1.start();
t2.start();
t3.start();
_test();
t1.join();
t2.join();
t3.join();
}
System.out.println("End highwatermark " + Highwatermark.get());
long time = System.currentTimeMillis() - start;
System.out.printf("End to end took %.1f%n", time / 1e3);
}
/*
* Primary constructor, used to drive remainder of the test.
*
* Fork off the other side, then do your work.
*/
JavaxHTTPSConnection() throws Exception {
if (separateServerThread) {
startServer(true);
startClient(false);
} else {
startClient(true);
startServer(false);
}
/*
* Wait for other side to close down.
*/
if (separateServerThread) {
serverThread.join();
} else {
clientThread.join();
}
/*
* When we get here, the test is pretty much over.
*
* If the main thread excepted, that propagates back
* immediately. If the other thread threw an exception, we
* should report back.
*/
if (serverException != null) {
System.out.print("Server Exception:");
throw serverException;
}
if (clientException != null) {
System.out.print("Client Exception:");
throw clientException;
}
}
// --------------------------------actionDisconnect---------------------------
private void actionDisconnect() {
try {
oConn.disconnect();
tConn.join(2000);
tMain.join(2000);
} catch (Exception e) {
}
}
public static void main(String[] args) throws Exception {
if (args.length == 0) {
System.err.println("Usage: java PortForward <local-port> <listen-port>");
return;
}
int localPort = Integer.parseInt(args[0]);
int listenPort = Integer.parseInt(args[1]);
ServerSocket ss = new ServerSocket(listenPort);
final Socket in = ss.accept();
final Socket out = new Socket("127.0.0.1", localPort);
Thread in2out =
new Thread() {
public void run() {
try {
InputStream i = in.getInputStream();
OutputStream o = out.getOutputStream();
int b = i.read();
while (b >= 0) {
o.write((byte) b);
b = i.read();
}
o.close();
i.close();
} catch (Exception e) {
e.printStackTrace();
}
}
};
in2out.start();
Thread out2in =
new Thread() {
public void run() {
try {
InputStream i = out.getInputStream();
OutputStream o = in.getOutputStream();
int b = i.read();
while (b >= 0) {
o.write((byte) b);
b = i.read();
}
o.close();
i.close();
} catch (Exception e) {
e.printStackTrace();
}
}
};
out2in.start();
in2out.join();
out2in.join();
in.close();
out.close();
}
public static void main(String[] args) throws Exception {
int counter = 0;
while (true) {
Thread outThread = null;
Thread errThread = null;
try {
// org.pitest.mutationtest.instrument.MutationTestUnit#runTestInSeperateProcessForMutationRange
// *** start slave
ServerSocket commSocket = new ServerSocket(0);
int commPort = commSocket.getLocalPort();
System.out.println("commPort = " + commPort);
// org.pitest.mutationtest.execute.MutationTestProcess#start
// - org.pitest.util.CommunicationThread#start
FutureTask<Integer> commFuture = createFuture(commSocket);
// - org.pitest.util.WrappingProcess#start
// - org.pitest.util.JavaProcess#launch
Process slaveProcess = startSlaveProcess(commPort);
outThread = new Thread(new ReadFromInputStream(slaveProcess.getInputStream()), "stdout");
errThread = new Thread(new ReadFromInputStream(slaveProcess.getErrorStream()), "stderr");
outThread.start();
errThread.start();
// *** wait for slave to die
// org.pitest.mutationtest.execute.MutationTestProcess#waitToDie
// - org.pitest.util.CommunicationThread#waitToFinish
System.out.println("waitToFinish");
Integer controlReturned = commFuture.get();
System.out.println("controlReturned = " + controlReturned);
// NOTE: the following won't get called if commFuture.get() fails!
// - org.pitest.util.JavaProcess#destroy
outThread.interrupt(); // org.pitest.util.AbstractMonitor#requestStop
errThread.interrupt(); // org.pitest.util.AbstractMonitor#requestStop
slaveProcess.destroy();
} catch (Exception e) {
e.printStackTrace(System.out);
}
// test: the threads should exit eventually
outThread.join();
errThread.join();
counter++;
System.out.println("try " + counter + ": stdout and stderr threads exited normally");
}
}
/** Test the http protocol handler with one WWW-Authenticate header with the value "NTLM". */
static void testNTLM() throws Exception {
// server reply
String reply = authReplyFor("NTLM");
System.out.println("====================================");
System.out.println("Expect client to fail with 401 Unauthorized");
System.out.println(reply);
try (ServerSocket ss = new ServerSocket(0)) {
Client client = new Client(ss.getLocalPort());
Thread thr = new Thread(client);
thr.start();
// client ---- GET ---> server
// client <--- 401 ---- client
try (Socket s = ss.accept()) {
new MessageHeader().parseHeader(s.getInputStream());
s.getOutputStream().write(reply.getBytes("US-ASCII"));
}
// the client should fail with 401
System.out.println("Waiting for client to terminate");
thr.join();
IOException ioe = client.ioException();
if (ioe != null) System.out.println("Client failed: " + ioe);
int respCode = client.respCode();
if (respCode != 0 && respCode != -1)
System.out.println("Client received HTTP response code: " + respCode);
if (respCode != HttpURLConnection.HTTP_UNAUTHORIZED)
throw new RuntimeException("Unexpected response code");
}
}
public static void main(String[] args) {
BufferedReader in;
try {
in =
new BufferedReader(
new FileReader(
"/Users/rahulkhairwar/Documents/IntelliJ IDEA Workspace/Competitive "
+ "Programming/src/com/google/codejam16/qualificationround/inputB.txt"));
OutputWriter out = new OutputWriter(System.out);
Thread thread = new Thread(null, new Solver(in, out), "Solver", 1 << 28);
thread.start();
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
out.flush();
in.close();
out.close();
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
// Do some simple concurrent testing
public void testConcurrentSimple() throws InterruptedException {
final NonBlockingIdentityHashMap<String, String> nbhm =
new NonBlockingIdentityHashMap<String, String>();
final String[] keys = new String[20000];
for (int i = 0; i < 20000; i++) keys[i] = "k" + i;
// In 2 threads, add & remove even & odd elements concurrently
Thread t1 =
new Thread() {
public void run() {
work_helper(nbhm, "T1", 1, keys);
}
};
t1.start();
work_helper(nbhm, "T0", 0, keys);
t1.join();
// In the end, all members should be removed
StringBuffer buf = new StringBuffer();
buf.append("Should be emptyset but has these elements: {");
boolean found = false;
for (String x : nbhm.keySet()) {
buf.append(" ").append(x);
found = true;
}
if (found) System.out.println(buf + " }");
assertThat("concurrent size=0", nbhm.size(), is(0));
for (String x : nbhm.keySet()) {
assertTrue("No elements so never get here", false);
}
}
/**
* Closes the server socket and the connections with all clients. Any exception thrown while
* closing a client is ignored. If one wishes to catch these exceptions, then clients should be
* individually closed before calling this method. The method also stops listening if this thread
* is running. If the server is already closed, this call has no effect.
*
* @exception IOException if an I/O error occurs while closing the server socket.
*/
public final void close() throws IOException {
if (serverSocket == null) return;
stopListening();
try {
serverSocket.close();
} finally {
synchronized (this) {
// Close the client sockets of the already connected clients
Thread[] clientThreadList = getClientConnections();
for (int i = 0; i < clientThreadList.length; i++) {
try {
((ConnectionToClient) clientThreadList[i]).close();
}
// Ignore all exceptions when closing clients.
catch (Exception ex) {
}
}
serverSocket = null;
}
try {
connectionListener.join(); // Wait for the end of listening thread.
} catch (InterruptedException ex) {
} catch (NullPointerException ex) {
} // When thread already dead.
serverClosed();
}
}
/** Stops unicast and multicast receiver threads */
void stopThreads() {
Thread tmp;
// 1. Stop the multicast receiver thread
if (mcast_receiver != null) {
if (mcast_receiver.isAlive()) {
tmp = mcast_receiver;
mcast_receiver = null;
closeMulticastSocket(); // will cause the multicast thread to terminate
tmp.interrupt();
try {
tmp.join(100);
} catch (Exception e) {
}
tmp = null;
}
mcast_receiver = null;
}
// 2. Stop the unicast receiver thread
if (ucast_receiver != null) {
ucast_receiver.stop();
ucast_receiver = null;
}
// 3. Stop the in_packet_handler thread
if (incoming_packet_handler != null) {
incoming_packet_handler.stop();
}
}
/** stopSending attempts to stop the thread, then waits for thread to stop. */
public void stopSending() {
_keepRunning = false;
try {
_sendThread.join();
} catch (InterruptedException e) {
}
}
public void run() {
try {
if (myPreviousThread != null) myPreviousThread.join();
Thread.sleep(delay);
log("> run MouseMoveThread " + x + ", " + y);
while (!hasFocus()) {
Thread.sleep(1000);
}
int x1 = lastMouseX;
int x2 = x;
int y1 = lastMouseY;
int y2 = y;
// shrink range by 1 px on both ends
// manually move this 1px to trip DND code
if (x1 != x2) {
int dx = x - lastMouseX;
if (dx > 0) {
x1 += 1;
x2 -= 1;
} else {
x1 -= 1;
x2 += 1;
}
}
if (y1 != y2) {
int dy = y - lastMouseY;
if (dy > 0) {
y1 += 1;
y2 -= 1;
} else {
y1 -= 1;
y2 += 1;
}
}
robot.setAutoDelay(Math.max(duration / 100, 1));
robot.mouseMove(x1, y1);
int d = 100;
for (int t = 0; t <= d; t++) {
x1 =
(int)
easeInOutQuad(
(double) t, (double) lastMouseX, (double) x2 - lastMouseX, (double) d);
y1 =
(int)
easeInOutQuad(
(double) t, (double) lastMouseY, (double) y2 - lastMouseY, (double) d);
robot.mouseMove(x1, y1);
}
robot.mouseMove(x, y);
lastMouseX = x;
lastMouseY = y;
robot.waitForIdle();
robot.setAutoDelay(1);
} catch (Exception e) {
log("Bad parameters passed to mouseMove");
e.printStackTrace();
}
log("< run MouseMoveThread");
}
public void onDestroy() {
running = false;
if (scanThread != null) scanThread.interrupt();
if (myWLocate != null) myWLocate.doPause();
sensorManager.unregisterListener(
this, sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER));
if (scanData.getmView() != null) {
((WindowManager) getSystemService(WINDOW_SERVICE)).removeView(scanData.getmView());
scanData.setmView(null);
}
try {
if (wl != null) wl.release();
} catch (RuntimeException re) {
}
wl = null;
try {
scanThread.join(1000);
} catch (InterruptedException ie) {
}
System.exit(0);
}
public boolean request(Object soaprequest) {
if (!checkSoapMemberVariable()) return false;
ServiceRequest req =
new ServiceRequest(
this.ServerUrl,
this.SoapAction,
this.NameSpace,
this.MethodName,
this.SoapVersion,
this.DotNet,
(SoapObject) soaprequest);
Thread thread = new Thread(req);
try {
thread.start();
thread.join();
} catch (Exception e) {
this.Response = null;
e.printStackTrace();
return false;
}
this.Response = req.getResponse();
if (this.Response == null) return false;
return true;
}
public static void main(String[] args) throws Exception {
int N = 6000;
if (args.length >= 1) N = Integer.parseInt(args[0]);
Crb = new double[N + 7];
Cib = new double[N + 7];
double invN = 2.0 / N;
for (int i = 0; i < N; i++) {
Cib[i] = i * invN - 1.0;
Crb[i] = i * invN - 1.5;
}
yCt = new AtomicInteger();
out = new byte[N][(N + 7) / 8];
Thread[] pool = new Thread[2 * Runtime.getRuntime().availableProcessors()];
for (int i = 0; i < pool.length; i++)
pool[i] =
new Thread() {
public void run() {
int y;
while ((y = yCt.getAndIncrement()) < out.length) putLine(y, out[y]);
}
};
for (Thread t : pool) t.start();
for (Thread t : pool) t.join();
OutputStream stream = new BufferedOutputStream(System.out);
stream.write(("P4\n" + N + " " + N + "\n").getBytes());
for (int i = 0; i < N; i++) stream.write(out[i]);
stream.close();
}
/** {@inheritDoc} */
public void updateBlock(Block oldblock, Block newblock) throws IOException {
if (oldblock.getBlockId() != newblock.getBlockId()) {
throw new IOException(
"Cannot update oldblock (=" + oldblock + ") to newblock (=" + newblock + ").");
}
for (; ; ) {
final List<Thread> threads = tryUpdateBlock(oldblock, newblock);
if (threads == null) {
return;
}
// interrupt and wait for all ongoing create threads
for (Thread t : threads) {
t.interrupt();
}
for (Thread t : threads) {
try {
t.join();
} catch (InterruptedException e) {
DataNode.LOG.warn("interruptOngoingCreates: t=" + t, e);
}
}
}
}
public void stop() {
running.set(false);
try {
thread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void start(ContentHandler sax, Target target) throws IOException, SAXException {
this.target = target;
XMLReader parser;
try {
parser = spf.newSAXParser().getXMLReader();
} catch (ParserConfigurationException e) {
throw new LagoonException(e.getMessage());
}
parser.setContentHandler(sax);
parser.setEntityResolver(
new EntityResolver() {
public InputSource resolveEntity(String publicId, String systemId)
throws SAXException, IOException {
InputSource is = new InputSource(getSourceMan().getFileURL(systemId));
File fil = getSourceMan().getFile(systemId);
if (fil != null) {
InputStream istr = new FileInputStream(fil);
is.setByteStream(istr);
}
return is;
}
});
exception = null;
mis = new MyInputStream();
mos = new MyOutputStream(mis);
thread = new Thread(this);
thread.start();
parser.parse(new InputSource(mis));
mis.close();
try {
thread.join(1000);
} catch (InterruptedException e) {
}
if (thread.isAlive()) {
thread.interrupt();
}
this.target = null;
if (exception != null) {
if (exception instanceof SAXException) {
throw (SAXException) exception;
} else if (exception instanceof IOException) {
throw (IOException) exception;
}
}
}
/*
* Primary constructor, used to drive remainder of the test.
*
* Fork off the other side, then do your work.
*/
InvalidateServerSessionRenegotiate() throws Exception {
if (separateServerThread) {
startServer(true);
startClient(false);
} else {
startClient(true);
startServer(false);
}
/*
* Wait for other side to close down.
*/
if (separateServerThread) {
serverThread.join();
} else {
clientThread.join();
}
/*
* When we get here, the test is pretty much over.
*
* If the main thread excepted, that propagates back
* immediately. If the other thread threw an exception, we
* should report back.
*/
if (serverException != null) {
System.out.print("Server Exception:");
throw serverException;
}
if (clientException != null) {
System.out.print("Client Exception:");
throw clientException;
}
/*
* Give the Handshaker Thread a chance to run
*/
Thread.sleep(1000);
synchronized (this) {
if (handshakesCompleted != 2) {
throw new Exception("Didn't see 2 handshake completed events.");
}
}
}
public static void main(String[] args) throws Exception {
TypeServer ts = new TypeServer();
ts.port = Integer.parseInt(args[0]);
Thread t = new Thread(ts);
t.start();
System.out.println("Type server ready...Type CTRL-D to exit");
while (System.in.read() > 0) ;
ts.stopServer();
t.join();
}
public static void main(String[] args) {
Thread thread = new Thread(new Download(args));
thread.setDaemon(true);
thread.start();
try {
thread.join();
} catch (Exception e) {
e.printStackTrace();
}
}
/** Stop the server. */
public void stop() {
try {
safeClose(myServerSocket);
closeAllConnections();
if (myThread != null) {
myThread.join();
}
} catch (Exception e) {
e.printStackTrace();
}
}
synchronized void waitUntilCompleted(long timeout, boolean resume) {
if (thread != null) {
try {
thread.join(timeout);
} catch (InterruptedException e) {
Thread.currentThread().interrupt(); // set interrupt flag again
}
thread = null; // Added after Brian noticed that ViewHandler leaks class loaders
}
if (resume) resumeForce();
}
public void stop() {
if (streamReader == null || !streamReader.isAlive()) {
System.out.println("Camera already stopped");
return;
}
keepAlive = false;
try {
streamReader.join();
} catch (InterruptedException e) {
System.err.println(e.getMessage());
}
}
void solve() {
Thread tcThread = new Thread(tc);
// System.out.println("starting client thread");
tcThread.start();
try {
tcThread.join();
} catch (Exception e) {
e.printStackTrace();
}
// System.out.println("joined client thread");
result = SudokuSolver.solve(tc.testcase);
success = SudokuSolver.isLegalSolution(result, tc.testcase);
}
/**
* When the server-side connector webapp is shutdown by the servlet container, the
* ServerNotificationManager calls this method. All pending notifications are dropped.
*/
public void close() {
exiting = true;
synchronized (que) {
que.notify();
}
try {
dispatchThr.join();
} catch (InterruptedException intre) {
}
try {
out.close();
} catch (IOException ioe) {
// XXX: Log it
}
}
@Test
public void shouldPurgeDiskDumpAndRepositoryWhenAsked()
throws IOException, ClassNotFoundException, InterruptedException {
SuiteTimeRepo fooRepo = factory.createSuiteTimeRepo("foo", LATEST_VERSION);
fooRepo.update(new SuiteTimeEntry("foo.bar.Baz", 15));
fooRepo.update(new SuiteTimeEntry("foo.bar.Quux", 80));
final Thread exitHook = factory.exitHook();
exitHook.start();
exitHook.join();
factory.purge(fooRepo.identifier);
fooRepo = factory.createSuiteTimeRepo("foo", LATEST_VERSION);
assertThat(fooRepo.list().size(), is(0));
fooRepo = new EntryRepoFactory(env()).createSuiteTimeRepo("foo", LATEST_VERSION);
assertThat(fooRepo.list().size(), is(0));
}
public void run() {
try {
if (myPreviousThread != null) myPreviousThread.join();
Thread.sleep(delay);
log("> run MousePressThread");
while (!hasFocus()) {
Thread.sleep(1000);
}
robot.mousePress(mask);
robot.waitForIdle();
} catch (Exception e) {
log("Bad parameters passed to mousePress");
e.printStackTrace();
}
log("< run MousePressThread");
}