//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldPerform500ConcurrentRequests() throws InterruptedException, java.util.concurrent.ExecutionException //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: public virtual void shouldPerform500ConcurrentRequests() { PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.apache.http.impl.client.CloseableHttpClient httpClient = org.apache.http.impl.client.HttpClients.custom().setConnectionManager(cm).build(); CloseableHttpClient httpClient = HttpClients.custom().setConnectionManager(cm).build(); Callable <string> performRequest = new CallableAnonymousInnerClass(this, httpClient); int requestsCount = 500; ExecutorService service = Executors.newFixedThreadPool(requestsCount); IList <Callable <string> > requests = new List <Callable <string> >(); for (int i = 0; i < requestsCount; i++) { requests.Add(performRequest); } IList <Future <string> > futures = service.invokeAll(requests); service.shutdown(); service.awaitTermination(1, TimeUnit.HOURS); foreach (Future <string> future in futures) { assertEquals(future.get(), "[]"); } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void testConcurrentIsUserAuthorized() throws Exception public virtual void testConcurrentIsUserAuthorized() { int threadCount = 2; int invocationCount = 500; ExecutorService executorService = Executors.newFixedThreadPool(threadCount); try { List <Callable <Exception> > callables = new List <Callable <Exception> >(); for (int i = 0; i < invocationCount; i++) { callables.Add(new CallableAnonymousInnerClass(this)); } IList <Future <Exception> > futures = executorService.invokeAll(callables); foreach (Future <Exception> future in futures) { Exception exception = future.get(); if (exception != null) { fail("No exception expected: " + exception.Message); } } } finally { // reset original logging level executorService.shutdownNow(); executorService.awaitTermination(10, TimeUnit.SECONDS); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test(timeout = TIMEOUT_MS) public void shouldDiscoverCompleteTargetSetWithoutDeadlocks() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldDiscoverCompleteTargetSetWithoutDeadlocks() { // given ExecutorService es = Executors.newCachedThreadPool(); long endTimeMillis = DateTimeHelper.CurrentUnixTimeMillis() + RUN_TIME_MS; while (endTimeMillis > DateTimeHelper.CurrentUnixTimeMillis()) { ISet <MemberId> members = new HashSet <MemberId>(); for (int i = 0; i < 3; i++) { members.Add(new MemberId(System.Guid.randomUUID())); } DiscoveryServiceFactory sharedService = new SharedDiscoveryServiceFactory(); IList <Callable <Void> > discoveryJobs = new List <Callable <Void> >(); foreach (MemberId member in members) { discoveryJobs.Add(CreateDiscoveryJob(member, sharedService, members)); } IList <Future <Void> > results = es.invokeAll(discoveryJobs); foreach (Future <Void> result in results) { result.get(TIMEOUT_MS, MILLISECONDS); } } }
public static float[] getMedianErrorRates(LangDescriptor language, int maxNumFiles, int trials) { SubsetValidator validator = new SubsetValidator(language.corpusDir, language); IList <InputDocument> documents = Tool.load(validator.allFiles, language); float[] medians = new float[Math.Min(documents.Count, maxNumFiles) + 1]; int ncpu = Runtime.Runtime.availableProcessors(); if (FORCE_SINGLE_THREADED) { ncpu = 2; } ExecutorService pool = Executors.newFixedThreadPool(ncpu - 1); IList <Callable <Void> > jobs = new List <Callable <Void> >(); for (int i = 1; i <= Math.Min(validator.allFiles.Count, maxNumFiles); i++) { // i is corpus subset size //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int corpusSubsetSize = i; int corpusSubsetSize = i; Callable <Void> job = () => { try { IList <float?> errorRates = new List <float?>(); for (int trial = 1; trial <= trials; trial++) { // multiple trials per subset size org.antlr.codebuff.misc.Pair <InputDocument, IList <InputDocument> > sample = validator.selectSample(documents, corpusSubsetSize); Triple <Formatter, float?, float?> results = validate(language, sample.b, sample.a, true, false); // System.out.println(sample.a.fileName+" n="+corpusSubsetSize+": error="+results.c); // System.out.println("\tcorpus =\n\t\t"+Utils.join(sample.b.iterator(), "\n\t\t")); errorRates.Add(results.c); } errorRates.Sort(); int n = errorRates.Count; float median = errorRates[n / 2].Value; Console.WriteLine("median " + language.name + " error rate for n=" + corpusSubsetSize + " is " + median); medians[corpusSubsetSize] = median; } catch (Exception t) { t.printStackTrace(System.err); } return(null); }; jobs.Add(job); } pool.invokeAll(jobs); pool.shutdown(); bool terminated = pool.awaitTermination(60, TimeUnit.MINUTES); return(medians); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test void shouldBeConsistentAfterConcurrentWritesAndForces() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: internal virtual void ShouldBeConsistentAfterConcurrentWritesAndForces() { ExecutorService executorService = Executors.newCachedThreadPool(); try { for (int attempt = 0; attempt < 100; attempt++) { using (EphemeralFileSystemAbstraction fs = new EphemeralFileSystemAbstraction()) { File aFile = new File("contendedFile"); ICollection <Callable <Void> > workers = new List <Callable <Void> >(); for (int i = 0; i < 100; i++) { workers.Add(() => { try { StoreChannel channel = fs.Open(aFile, OpenMode.READ_WRITE); channel.position(channel.size()); WriteLong(channel, 1); } catch (IOException e) { throw new Exception(e); } return(null); }); workers.Add(() => { StoreChannel channel = fs.Open(aFile, OpenMode.READ_WRITE); channel.force(true); return(null); }); } IList <Future <Void> > futures = executorService.invokeAll(workers); foreach (Future <Void> future in futures) { future.get(); } fs.Crash(); VerifyFileIsFullOfLongIntegerOnes(fs.Open(aFile, OpenMode.READ_WRITE)); } } } finally { executorService.shutdown(); } }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldWorkWhileHavingHeavyConcurrentUpdates() throws Exception //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldWorkWhileHavingHeavyConcurrentUpdates() { // given some initial data //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long[] nodes = repeatCreateNamedPeopleFor(NAMES.length * CREATION_MULTIPLIER); long[] nodes = RepeatCreateNamedPeopleFor(_names.Length * _creationMultiplier); int initialNodes = nodes.Length; int threads = 5; _indexOnlineMonitor.initialize(threads); ExecutorService executorService = Executors.newFixedThreadPool(threads); // when populating while creating //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.neo4j.internal.kernel.api.IndexReference index = createPersonNameIndex(); IndexReference index = CreatePersonNameIndex(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.Collection<java.util.concurrent.Callable<UpdatesTracker>> jobs = new java.util.ArrayList<>(threads); ICollection <Callable <UpdatesTracker> > jobs = new List <Callable <UpdatesTracker> >(threads); for (int i = 0; i < threads; i++) { jobs.Add(() => ExecuteCreationsDeletionsAndUpdates(nodes, _creationMultiplier)); } IList <Future <UpdatesTracker> > futures = executorService.invokeAll(jobs); // sum result into empty result UpdatesTracker result = new UpdatesTracker(); result.NotifyPopulationCompleted(); foreach (Future <UpdatesTracker> future in futures) { result.Add(future.get()); } AwaitIndexesOnline(); executorService.shutdown(); assertTrue(executorService.awaitTermination(1, TimeUnit.MINUTES)); // then AssertIndexedNodesMatchesStoreNodes(); int seenWhilePopulating = initialNodes + result.CreatedDuringPopulation() - result.DeletedDuringPopulation(); double expectedSelectivity = UNIQUE_NAMES / seenWhilePopulating; AssertCorrectIndexSelectivity(expectedSelectivity, IndexSelectivity(index)); AssertCorrectIndexSize("Tracker had " + result, seenWhilePopulating, IndexSize(index)); int expectedIndexUpdates = result.DeletedAfterPopulation() + result.CreatedAfterPopulation() + result.UpdatedAfterPopulation(); AssertCorrectIndexUpdates("Tracker had " + result, expectedIndexUpdates, IndexUpdates(index)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private void execute(java.util.List<RecordStresser> recordStressers) throws InterruptedException, java.util.concurrent.ExecutionException private void Execute(IList <RecordStresser> recordStressers) { ExecutorService executorService = Executors.newFixedThreadPool(_numberOfThreads, r => { Thread thread = Executors.defaultThreadFactory().newThread(r); thread.Daemon = true; return(thread); }); IList <Future <Void> > futures = executorService.invokeAll(recordStressers); foreach (Future <Void> future in futures) { future.get(); } executorService.shutdown(); assertTrue(executorService.awaitTermination(10, TimeUnit.SECONDS)); }
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes: //ORIGINAL LINE: @Test public void shouldRunSimpleStatement() throws Throwable //JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: public virtual void ShouldRunSimpleStatement() { // Given int numWorkers = 5; int numRequests = 1_000; IList <Callable <Void> > workers = CreateWorkers(numWorkers, numRequests); ExecutorService exec = Executors.newFixedThreadPool(numWorkers); try { // When & then foreach (Future <Void> f in exec.invokeAll(workers)) { f.get(60, TimeUnit.SECONDS); } } finally { exec.shutdownNow(); exec.awaitTermination(30, TimeUnit.SECONDS); } }
public static void Main(string[] args) { LangDescriptor[] languages = new LangDescriptor[] { Tool.ANTLR4_DESCR }; int MAX_K = 98; // should be odd int OUTLIER_K = 99; IList <int?> ks = new List <int?>(); for (int i = 1; i <= MAX_K; i += 2) { ks.Add(i); } ks.Add(OUTLIER_K); // track medians[language][k] float[][] medians = new float[languages.Length + 1][]; int ncpu = 1; if (FORCE_SINGLE_THREADED) { ncpu = 2; } ExecutorService pool = Executors.newFixedThreadPool(ncpu - 1); IList <Callable <Void> > jobs = new List <Callable <Void> >(); for (int i = 0; i < languages.Length; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.antlr.codebuff.misc.LangDescriptor language = languages[i]; LangDescriptor language = languages[i]; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int langIndex = i; int langIndex = i; Log.WriteLine(language.name); foreach (int k in ks) { medians[langIndex] = new float?[OUTLIER_K + 1]; Callable <Void> job = () => { try { TestK tester = new TestK(language.corpusDir, language, k); IList <float?> errorRates = tester.scoreDocuments(); errorRates.Sort(); int n = errorRates.Count; float median = errorRates[n / 2].Value; // double var = BuffUtils.varianceFloats(errorRates); // String display = String.format("%5.4f, %5.4f, %5.4f, %5.4f, %5.4f", min, quart, median, quart3, max); medians[langIndex][k] = median; } catch (Exception t) { t.printStackTrace(System.err); } return(null); }; jobs.Add(job); } } pool.invokeAll(jobs); pool.shutdown(); bool terminated = pool.awaitTermination(60, TimeUnit.MINUTES); writePython(languages, ks, medians); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#: //ORIGINAL LINE: private long[] repeatCreateNamedPeopleFor(int totalNumberOfPeople) throws Exception private long[] RepeatCreateNamedPeopleFor(int totalNumberOfPeople) { // Parallelize the creation of persons //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final long[] nodes = new long[totalNumberOfPeople]; long[] nodes = new long[totalNumberOfPeople]; const int threads = 100; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int peoplePerThread = totalNumberOfPeople / threads; int peoplePerThread = totalNumberOfPeople / threads; //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.ExecutorService service = java.util.concurrent.Executors.newFixedThreadPool(threads); ExecutorService service = Executors.newFixedThreadPool(threads); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.concurrent.atomic.AtomicReference<org.neo4j.internal.kernel.api.exceptions.KernelException> exception = new java.util.concurrent.atomic.AtomicReference<>(); AtomicReference <KernelException> exception = new AtomicReference <KernelException>(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.List<java.util.concurrent.Callable<Void>> jobs = new java.util.ArrayList<>(threads); IList <Callable <Void> > jobs = new List <Callable <Void> >(threads); // Start threads that creates these people, relying on batched writes to speed things up for (int i = 0; i < threads; i++) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final int finalI = i; int finalI = i; jobs.Add(() => { int offset = finalI * peoplePerThread; while (offset < (finalI + 1) * peoplePerThread) { try { offset += CreateNamedPeople(nodes, offset); } catch (KernelException e) { exception.compareAndSet(null, e); throw new Exception(e); } } return(null); }); } //JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET: //ORIGINAL LINE: for (java.util.concurrent.Future<?> job : service.invokeAll(jobs)) foreach (Future <object> job in service.invokeAll(jobs)) { job.get(); } service.awaitTermination(1, TimeUnit.SECONDS); service.shutdown(); // Make any KernelException thrown from a creation thread visible in the main thread Exception ex = exception.get(); if (ex != null) { throw ex; } return(nodes); }