Beispiel #1
0
    @Override
    protected void compute() {
      int i = start;
      int j = end;
      int swap = -1;

      while (i < j) {
        while (i < j && nums[i] <= nums[j]) j--;
        if (i < j) {
          swap = nums[i];
          nums[i] = nums[j];
          nums[j] = swap;
        }
        while (i < j && nums[i] < nums[j]) i++;
        if (i < j) {
          swap = nums[i];
          nums[i] = nums[j];
          nums[j] = swap;
        }
      }
      List<ForkJoinTask<Void>> tasks = new LinkedList<>();

      if (i - start > 1) {
        tasks.add(new ForkJoinFastSort(nums, 0, i - 1).fork());
      }
      if (end - j > 1) {
        tasks.add(new ForkJoinFastSort(nums, j + 1, end).fork());
      }
      for (ForkJoinTask<Void> task : tasks) {
        task.join();
      }
    }
Beispiel #2
0
  public static void main(String[] args) {
    int[] nums = new int[] {5, 4, 6, 2, 8, 7, 9, 1, 3};

    ForkJoinPool pool = new ForkJoinPool();
    ForkJoinTask<Void> t = pool.submit(new ForkJoinFastSort(nums, 0, 8));
    t.join();
    for (int i : nums) {
      System.err.print(i);
    }
  }
 @Override
 protected T compute() {
   List<ForkJoinTask<T>> passes = Lists.newArrayListWithCapacity(nSubOptimizers);
   for (int i = 0; i < nSubOptimizers; i++) {
     passes.add(new SingleOptimizationStep(initial, temp).fork());
   }
   T currentBest = initial;
   double currentBestScore = scorer.score(initial);
   for (ForkJoinTask<T> pass : passes) {
     T better = pass.join();
     double betterScore = scorer.score(better);
     if (betterScore > currentBestScore) {
       currentBest = better;
       currentBestScore = betterScore;
     }
   }
   return currentBest;
 }
 /**
  * Wait for all the childPid tasks to complete, and then create the relations
  *
  * @throws BackendMethodFailedException
  * @throws BackendInvalidResourceException
  * @throws BackendInvalidCredsException
  */
 private void handleNodeEnd()
     throws BackendMethodFailedException, BackendInvalidResourceException,
         BackendInvalidCredsException {
   ArrayList<String> childRealPids = new ArrayList<>();
   for (ForkJoinTask<String> childPid : childTasks) {
     childRealPids.add(childPid.join());
   }
   String comment =
       "Added relationship from " + myPid + " hasPart to " + childRealPids.size() + " children";
   AddRelationsRequest addRelationsRequest = new AddRelationsRequest();
   addRelationsRequest.setPid(myPid);
   addRelationsRequest.setSubject(null);
   addRelationsRequest.setPredicate(hasPartRelation);
   addRelationsRequest.setObjects(childRealPids);
   addRelationsRequest.setComment("Modified by " + getClass().getSimpleName());
   UniqueRelationsCreator uniqueRelationsCreator = new UniqueRelationsCreator(fedora);
   uniqueRelationsCreator.addRelationships(addRelationsRequest);
   // fedora.addRelations(myPid, null, hasPartRelation, childRealPids, false, comment);
   log.debug("{}, " + comment, myPid);
 }
Beispiel #5
0
 /**
  * Sorts all the elements of the given array using the ForkJoin framework
  *
  * @param array the array to sort
  */
 public void sort(int[] array) {
   ForkJoinTask<Void> job = pool.submit(new MergeSortTask(array, 0, array.length));
   job.join();
 }
  @Test
  public void testAsyncRangeRequests()
      throws IOException, URISyntaxException, InterruptedException {
    final URL testResourceUrl = new URL(VAULT_BASE_URI.toURL(), "asyncRangeRequestTestFile.txt");

    final MultiThreadedHttpConnectionManager cm = new MultiThreadedHttpConnectionManager();
    cm.getParams().setDefaultMaxConnectionsPerHost(50);
    final HttpClient client = new HttpClient(cm);

    // prepare 8MiB test data:
    final byte[] plaintextData = new byte[2097152 * Integer.BYTES];
    final ByteBuffer bbIn = ByteBuffer.wrap(plaintextData);
    for (int i = 0; i < 2097152; i++) {
      bbIn.putInt(i);
    }

    // put request:
    final EntityEnclosingMethod putMethod = new PutMethod(testResourceUrl.toString());
    putMethod.setRequestEntity(new ByteArrayRequestEntity(plaintextData));
    final int putResponse = client.executeMethod(putMethod);
    putMethod.releaseConnection();
    Assert.assertEquals(201, putResponse);

    // multiple async range requests:
    final List<ForkJoinTask<?>> tasks = new ArrayList<>();
    final Random generator = new Random(System.currentTimeMillis());

    final AtomicBoolean success = new AtomicBoolean(true);

    // 10 full interrupted requests:
    for (int i = 0; i < 10; i++) {
      final ForkJoinTask<?> task =
          ForkJoinTask.adapt(
              () -> {
                try {
                  final HttpMethod getMethod = new GetMethod(testResourceUrl.toString());
                  final int statusCode = client.executeMethod(getMethod);
                  if (statusCode != 200) {
                    LOG.error("Invalid status code for interrupted full request");
                    success.set(false);
                  }
                  getMethod.getResponseBodyAsStream().read();
                  getMethod.getResponseBodyAsStream().close();
                  getMethod.releaseConnection();
                } catch (IOException e) {
                  throw new RuntimeException(e);
                }
              });
      tasks.add(task);
    }

    // 50 crappy interrupted range requests:
    for (int i = 0; i < 50; i++) {
      final int lower = generator.nextInt(plaintextData.length);
      final ForkJoinTask<?> task =
          ForkJoinTask.adapt(
              () -> {
                try {
                  final HttpMethod getMethod = new GetMethod(testResourceUrl.toString());
                  getMethod.addRequestHeader("Range", "bytes=" + lower + "-");
                  final int statusCode = client.executeMethod(getMethod);
                  if (statusCode != 206) {
                    LOG.error("Invalid status code for interrupted range request");
                    success.set(false);
                  }
                  getMethod.getResponseBodyAsStream().read();
                  getMethod.getResponseBodyAsStream().close();
                  getMethod.releaseConnection();
                } catch (IOException e) {
                  throw new RuntimeException(e);
                }
              });
      tasks.add(task);
    }

    // 50 normal open range requests:
    for (int i = 0; i < 50; i++) {
      final int lower = generator.nextInt(plaintextData.length - 512);
      final int upper = plaintextData.length - 1;
      final ForkJoinTask<?> task =
          ForkJoinTask.adapt(
              () -> {
                try {
                  final HttpMethod getMethod = new GetMethod(testResourceUrl.toString());
                  getMethod.addRequestHeader("Range", "bytes=" + lower + "-");
                  final byte[] expected = Arrays.copyOfRange(plaintextData, lower, upper + 1);
                  final int statusCode = client.executeMethod(getMethod);
                  final byte[] responseBody = new byte[upper - lower + 10];
                  final int bytesRead =
                      IOUtils.read(getMethod.getResponseBodyAsStream(), responseBody);
                  getMethod.releaseConnection();
                  if (statusCode != 206) {
                    LOG.error("Invalid status code for open range request");
                    success.set(false);
                  } else if (upper - lower + 1 != bytesRead) {
                    LOG.error("Invalid response length for open range request");
                    success.set(false);
                  } else if (!Arrays.equals(
                      expected, Arrays.copyOfRange(responseBody, 0, bytesRead))) {
                    LOG.error("Invalid response body for open range request");
                    success.set(false);
                  }
                } catch (IOException e) {
                  throw new RuntimeException(e);
                }
              });
      tasks.add(task);
    }

    // 200 normal closed range requests:
    for (int i = 0; i < 200; i++) {
      final int pos1 = generator.nextInt(plaintextData.length - 512);
      final int pos2 = pos1 + 512;
      final ForkJoinTask<?> task =
          ForkJoinTask.adapt(
              () -> {
                try {
                  final int lower = Math.min(pos1, pos2);
                  final int upper = Math.max(pos1, pos2);
                  final HttpMethod getMethod = new GetMethod(testResourceUrl.toString());
                  getMethod.addRequestHeader("Range", "bytes=" + lower + "-" + upper);
                  final byte[] expected = Arrays.copyOfRange(plaintextData, lower, upper + 1);
                  final int statusCode = client.executeMethod(getMethod);
                  final byte[] responseBody = new byte[upper - lower + 1];
                  final int bytesRead =
                      IOUtils.read(getMethod.getResponseBodyAsStream(), responseBody);
                  getMethod.releaseConnection();
                  if (statusCode != 206) {
                    LOG.error("Invalid status code for closed range request");
                    success.set(false);
                  } else if (upper - lower + 1 != bytesRead) {
                    LOG.error("Invalid response length for closed range request");
                    success.set(false);
                  } else if (!Arrays.equals(
                      expected, Arrays.copyOfRange(responseBody, 0, bytesRead))) {
                    LOG.error("Invalid response body for closed range request");
                    success.set(false);
                  }
                } catch (IOException e) {
                  throw new RuntimeException(e);
                }
              });
      tasks.add(task);
    }

    Collections.shuffle(tasks, generator);

    final ForkJoinPool pool = new ForkJoinPool(4);
    for (ForkJoinTask<?> task : tasks) {
      pool.execute(task);
    }
    for (ForkJoinTask<?> task : tasks) {
      task.join();
    }
    pool.shutdown();
    cm.shutdown();

    Assert.assertTrue(success.get());
  }