Parallelize recipe removal

Signed-off-by: Glease <[email protected]>
This commit is contained in:
Glease committed 2021-12-17 04:43:05 +08:00
1 parent 5044de32dd
commit 67ef22c4cc
3 files changed
+674 -108

No files matched your search

@@ -16,6 +16,7 @@ import minetweaker.api.recipes.ShapedRecipe;
import minetweaker.api.recipes.ShapelessRecipe;
import minetweaker.mc1710.item.MCItemStack;
import minetweaker.mc1710.util.MineTweakerHacks;
import minetweaker.mc1710.util.ThreadSafeBitSet;
import minetweaker.util.IEventHandler;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.Container;
@@ -30,12 +31,11 @@ import net.minecraftforge.oredict.ShapelessOreRecipe;
import org.apache.commons.lang3.tuple.Pair;
import stanhebben.zenscript.annotations.Optional;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.*;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.RecursiveAction;
import java.util.concurrent.RecursiveTask;
import java.util.stream.Collectors;
import static minetweaker.api.minecraft.MineTweakerMC.getIItemStack;
import static minetweaker.api.minecraft.MineTweakerMC.getItemStack;
@@ -269,6 +269,8 @@ public final class MCRecipeManager implements IRecipeManager {
}
public abstract static class ActionBaseRemoveRecipes implements IUndoableAction {
public abstract boolean matches(IRecipe r);
public abstract Set<IRecipe> find();
public void removeRecipes(Set<IRecipe> toRemove ) {
recipes.removeIf(toRemove::contains);
}
@@ -277,7 +279,7 @@ public final class MCRecipeManager implements IRecipeManager {
public static class ActionRemoveRecipesNoIngredients extends ActionBaseRemoveRecipes implements IUndoableAction {
// pair of output, nbtMatch
private final List<Pair<IIngredient, Boolean>> outputs = new ArrayList<>();
private final Set<IRecipe> toRemove = new HashSet<>();
private Set<IRecipe> toRemove = new HashSet<>();
public void addOutput(IIngredient output, @Optional boolean nbtMatch) {
outputs.add(Pair.of(output, nbtMatch));
@@ -288,19 +290,25 @@ public final class MCRecipeManager implements IRecipeManager {
}
@Override
public void apply() {
toRemove.clear();
public boolean matches(IRecipe r) {
ItemStack recipeOutput = r.getRecipeOutput();
return recipeOutput != null && matches(getIItemStack(recipeOutput));
}
for (final IRecipe recipe : recipes) {
final ItemStack recipeOutput = recipe.getRecipeOutput();
if (recipeOutput != null) {
final IItemStack stack = getIItemStack(recipeOutput);
if (matches(stack)) {
toRemove.add(recipe);
}
}
}
super.removeRecipes(toRemove);
@Override
public Set<IRecipe> find() {
return recipes.parallelStream()
.filter(r -> {
ItemStack recipeOutput = r.getRecipeOutput();
return recipeOutput != null && matches(getIItemStack(recipeOutput));
}).collect(Collectors.toSet());
}
@Override
public void apply() {
toRemove = find();
removeRecipes(toRemove);
}
@Override
@@ -354,68 +362,77 @@ public final class MCRecipeManager implements IRecipeManager {
this.ingredients = ingredients;
this.wildcard = wildcard;
}
@Override
public void apply() {
toRemove.clear();
public boolean matches(IRecipe recipe) {
if (recipe.getRecipeOutput() == null || !output.matches(new MCItemStack(recipe.getRecipeOutput()))) {
return false;
}
if (recipe instanceof ShapedRecipes) {
return false;
}
if (!(recipe instanceof ShapelessRecipes) && !(recipe instanceof ShapelessOreRecipe)) {
return false;
}
if (ingredients != null) {
if (recipe instanceof ShapelessRecipes) {
ShapelessRecipes srecipe = (ShapelessRecipes) recipe;
outer:
for (IRecipe recipe : recipes) {
if (recipe.getRecipeOutput() == null || !output.matches(new MCItemStack(recipe.getRecipeOutput()))) {
continue;
}
if (recipe instanceof ShapedRecipes) {
continue;
}
if (!(recipe instanceof ShapelessRecipes) && !(recipe instanceof ShapelessOreRecipe)) {
continue;
}
if (ingredients != null) {
if (recipe instanceof ShapelessRecipes) {
ShapelessRecipes srecipe = (ShapelessRecipes) recipe;
if (ingredients.length > srecipe.getRecipeSize()) {
return false;
} else if (!wildcard && ingredients.length < srecipe.getRecipeSize()) {
return false;
}
if (ingredients.length > srecipe.getRecipeSize()) {
continue;
} else if (!wildcard && ingredients.length < srecipe.getRecipeSize()) {
continue;
}
checkIngredient:
for (IIngredient ingredient : ingredients) {
for (int k = 0; k < srecipe.getRecipeSize(); k++) {
if (matches(srecipe.recipeItems.get(k), ingredient)) {
continue checkIngredient;
}
checkIngredient:
for (IIngredient ingredient : ingredients) {
for (int k = 0; k < srecipe.getRecipeSize(); k++) {
if (MCRecipeManager.matches(srecipe.recipeItems.get(k), ingredient)) {
continue checkIngredient;
}
continue outer;
}
} else if (recipe instanceof ShapelessOreRecipe) {
ShapelessOreRecipe srecipe = (ShapelessOreRecipe) recipe;
ArrayList<Object> inputs = srecipe.getInput();
if (inputs.size() < ingredients.length) {
continue;
}
if (!wildcard && inputs.size() > ingredients.length) {
continue;
}
checkIngredient:
for (IIngredient ingredient : ingredients) {
for (int k = 0; k < srecipe.getRecipeSize(); k++) {
if (matches(inputs.get(k), ingredient)) {
continue checkIngredient;
}
return false;
}
} else if (recipe instanceof ShapelessOreRecipe) {
ShapelessOreRecipe srecipe = (ShapelessOreRecipe) recipe;
ArrayList<Object> inputs = srecipe.getInput();
if (inputs.size() < ingredients.length) {
return false;
}
if (!wildcard && inputs.size() > ingredients.length) {
return false;
}
checkIngredient:
for (IIngredient ingredient : ingredients) {
for (int k = 0; k < srecipe.getRecipeSize(); k++) {
if (MCRecipeManager.matches(inputs.get(k), ingredient)) {
continue checkIngredient;
}
continue outer;
}
return false;
}
}
toRemove.add(recipe);
}
return true;
}
@Override
public Set<IRecipe> find() {
Set<IRecipe> toRemove = new HashSet<>();
for (IRecipe recipe : recipes) {
if (matches(recipe))
toRemove.add(recipe);
}
return toRemove;
}
@Override
public void apply() {
toRemove = find();
MineTweakerAPI.logInfo("Removing " + toRemove.size() + " Shapeless recipes.");
super.removeRecipes(toRemove);
}
@@ -455,20 +472,17 @@ public final class MCRecipeManager implements IRecipeManager {
public static class ActionRemoveShapedRecipes extends ActionBaseRemoveRecipes implements IUndoableAction {
final IIngredient output;
final IIngredient[][] ingredients;
final Set<IRecipe> toRemove = new HashSet<>();
final int ingredientsWidth;
final int ingredientsHeight;
Set<IRecipe> toRemove = new HashSet<>();
public ActionRemoveShapedRecipes(IIngredient output, IIngredient[][] ingredients) {
this.output = output;
this.ingredients = ingredients;
}
@Override
public void apply() {
int ingredientsWidth = 0;
int ingredientsHeight = 0;
toRemove.clear();
if (ingredients != null) {
ingredientsHeight = ingredients.length;
@@ -477,43 +491,61 @@ public final class MCRecipeManager implements IRecipeManager {
ingredientsWidth = Math.max(ingredientsWidth, ingredient.length);
}
}
this.ingredientsWidth = ingredientsWidth;
this.ingredientsHeight = ingredientsHeight;
}
outer:
for (final IRecipe recipe : recipes) {
final ItemStack output = recipe.getRecipeOutput();
if (output == null || !this.output.matches(new MCItemStack(output))) {
continue;
@Override
public boolean matches(IRecipe recipe) {
final ItemStack output = recipe.getRecipeOutput();
if (output == null || !this.output.matches(new MCItemStack(output))) {
return false;
}
if (!(recipe instanceof ShapedRecipes || recipe instanceof ShapedOreRecipe))
return false;
if (ingredients != null) {
boolean ore = recipe instanceof ShapedOreRecipe;
final ShapedRecipes shapedRecipe = !ore ? (ShapedRecipes) recipe : null;
final ShapedOreRecipe shapedOreRecipe = ore ? (ShapedOreRecipe) recipe : null;
final int recipeWidth = ore ? MineTweakerHacks.getShapedOreRecipeWidth(shapedOreRecipe) : shapedRecipe.recipeWidth;
final int recipeHeight = ore ? shapedOreRecipe.getRecipeSize() / recipeWidth : shapedRecipe.recipeHeight;
if (ingredientsWidth != recipeWidth || ingredientsHeight != recipeHeight) {
return false;
}
if (!(recipe instanceof ShapedRecipes || recipe instanceof ShapedOreRecipe))
continue;
if (ingredients != null) {
boolean ore = recipe instanceof ShapedOreRecipe;
final ShapedRecipes shapedRecipe = !ore ? (ShapedRecipes) recipe : null;
final ShapedOreRecipe shapedOreRecipe = ore ? (ShapedOreRecipe) recipe : null;
final int recipeWidth = ore ? MineTweakerHacks.getShapedOreRecipeWidth(shapedOreRecipe) : shapedRecipe.recipeWidth;
final int recipeHeight = ore ? shapedOreRecipe.getRecipeSize() / recipeWidth : shapedRecipe.recipeHeight;
if (ingredientsWidth != recipeWidth || ingredientsHeight != recipeHeight) {
continue;
}
for (int j = 0; j < ingredientsHeight; j++) {
final IIngredient[] row = ingredients[j];
for (int k = 0; k < ingredientsWidth; k++) {
final IIngredient ingredient = k > row.length ? null : row[k];
final Object input = (ore ? shapedOreRecipe.getInput() : shapedRecipe.recipeItems)[j * recipeWidth + k];
for (int j = 0; j < ingredientsHeight; j++) {
final IIngredient[] row = ingredients[j];
for (int k = 0; k < ingredientsWidth; k++) {
final IIngredient ingredient = k > row.length ? null : row[k];
final Object input = (ore ? shapedOreRecipe.getInput() : shapedRecipe.recipeItems)[j * recipeWidth + k];
if (!matches(input, ingredient)) {
continue outer;
}
if (!MCRecipeManager.matches(input, ingredient)) {
return false;
}
}
}
// If null ingredient list given, remove all ShapedRecipes with the given output
toRemove.add(recipe);
}
// If null ingredient list given, remove all ShapedRecipes with the given output
return true;
}
@Override
public Set<IRecipe> find() {
Set<IRecipe> toRemove = new HashSet<>();
for (final IRecipe recipe : recipes) {
if (matches(recipe))
toRemove.add(recipe);
}
return toRemove;
}
@Override
public void apply() {
toRemove = find();
MineTweakerAPI.logInfo(toRemove.size() + " removed");
super.removeRecipes(toRemove);
@@ -627,6 +659,45 @@ public final class MCRecipeManager implements IRecipeManager {
super(new ShapelessRecipe(output, ingredients, function, action), output, false);
}
}
private static class ActionBatchRemoveRecipe implements IUndoableAction {
private final Set<IRecipe> recipes;
private ActionBatchRemoveRecipe(Set<IRecipe> recipes) {
this.recipes = recipes;
}
@Override
public void apply() {
System.out.println("Removing " + recipes.size() + " recipes");
MCRecipeManager.recipes.removeIf(recipes::contains);
}
@Override
public boolean canUndo() {
return true;
}
@Override
public void undo() {
recipesToAdd.addAll(recipes.parallelStream().map(ActionBaseAddRecipe::new).collect(Collectors.toList()));
}
@Override
public String describe() {
return "Batch Remove " + recipes.size() + " recipes";
}
@Override
public String describeUndo() {
return "Add back " + recipes.size() + "recipes";
}
@Override
public Object getOverrideKey() {
return null;
}
}
public static void applyAdditionsAndRemovals() {
System.out.println("MineTweaker: Applying additions and removals");
@@ -634,7 +705,22 @@ public final class MCRecipeManager implements IRecipeManager {
if(recipesToUndo.size() > 0) {
recipes.removeIf(recipesToUndo::contains);
}
MCRecipeManager.recipesToRemove.forEach(MineTweakerAPI::apply);
int commonPoolParallelism = getCommonPoolParallelism();
if (commonPoolParallelism <= 1) {
// if thread == 1, then we have parallel overhead but doesn't have parallel speedup.
// never do this
recipesToRemove.forEach(ActionBaseRemoveRecipes::apply);
} else
try {
ThreadSafeBitSet removed = new ThreadSafeBitSet();
new FindRecipeToRemoveTask(removed, recipesToRemove).fork().get();
MineTweakerAPI.apply(new ActionBatchRemoveRecipe(removed.toBitSet().stream().mapToObj(recipes::get).collect(Collectors.toSet())));
} catch (InterruptedException | ExecutionException e) {
System.err.println("MineTweaker: Parallel Removal failed. Falling back to sequential remove");
e.printStackTrace();
// try it sequentially
recipesToRemove.forEach(ActionBaseRemoveRecipes::apply);
}
MCRecipeManager.recipesToAdd.forEach(MineTweakerAPI::apply);
actionRemoveRecipesNoIngredients.clearOutputs();
@@ -643,6 +729,10 @@ public final class MCRecipeManager implements IRecipeManager {
recipesToUndo.clear();
}
private static int getCommonPoolParallelism() {
return Integer.getInteger("java.util.concurrent.ForkJoinPool.common.parallelism", Runtime.getRuntime().availableProcessors() - 1);
}
public static class HandleLateAdditionsAndRemovals implements IEventHandler<MineTweakerImplementationAPI.ReloadEvent>
{
@Override
@@ -658,5 +748,40 @@ public final class MCRecipeManager implements IRecipeManager {
return false;
}
}
/**
* A ForkJoinTask to find recipes to remove. Slightly more performant than parallelStream().
*/
private static class FindRecipeToRemoveTask extends RecursiveAction {
private final ThreadSafeBitSet removed;
private final List<ActionBaseRemoveRecipes> workList;
public FindRecipeToRemoveTask(ThreadSafeBitSet removed, List<ActionBaseRemoveRecipes> workList) {
this.removed = removed;
this.workList = workList;
}
@Override
protected void compute() {
if (workList.isEmpty()) return;
if (workList.size() < 50) {
for (int i = 0; i < recipes.size(); i++) {
if (removed.get(i)) continue;
IRecipe recipe = recipes.get(i);
for (ActionBaseRemoveRecipes r : workList) {
if (r.matches(recipe)) {
removed.set(i);
break;
}
}
}
} else {
FindRecipeToRemoveTask left = new FindRecipeToRemoveTask(removed, workList.subList(0, workList.size() / 2));
left.fork();
new FindRecipeToRemoveTask(removed, workList.subList(workList.size() / 2, workList.size())).fork().join();
left.join();
}
}
}
}
@@ -0,0 +1,441 @@
/*
* Copyright 2016-2019 Netflix, Inc.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package minetweaker.mc1710.util;
import java.io.DataOutputStream;
import java.io.IOException;
import java.util.Arrays;
import java.util.BitSet;
import java.util.concurrent.atomic.AtomicLongArray;
import java.util.concurrent.atomic.AtomicReference;
/**
* This is a lock-free, thread-safe version of a {@link java.util.BitSet}.<p>
*
* Instead of a long array to hold the bits, this implementation uses an AtomicLongArray, then
* does the appropriate compare-and-swap operations when setting the bits.
*
* @author dkoszewnik
*
*/
public class ThreadSafeBitSet {
public static final int DEFAULT_LOG2_SEGMENT_SIZE_IN_BITS = 14;
private final int numLongsPerSegment;
private final int log2SegmentSize;
private final int segmentMask;
private final AtomicReference<ThreadSafeBitSetSegments> segments;
public ThreadSafeBitSet() {
this(DEFAULT_LOG2_SEGMENT_SIZE_IN_BITS); /// 16384 bits, 2048 bytes, 256 longs per segment
}
public ThreadSafeBitSet(int log2SegmentSizeInBits) {
this(log2SegmentSizeInBits, 0);
}
public ThreadSafeBitSet(int log2SegmentSizeInBits, int numBitsToPreallocate) {
if(log2SegmentSizeInBits < 6)
throw new IllegalArgumentException("Cannot specify fewer than 64 bits in each segment!");
this.log2SegmentSize = log2SegmentSizeInBits;
this.numLongsPerSegment = (1 << (log2SegmentSizeInBits - 6));
this.segmentMask = numLongsPerSegment - 1;
long numBitsPerSegment = numLongsPerSegment * 64;
int numSegmentsToPreallocate = numBitsToPreallocate == 0 ? 1 : (int)(((numBitsToPreallocate - 1) / numBitsPerSegment) + 1);
segments = new AtomicReference<ThreadSafeBitSetSegments>();
segments.set(new ThreadSafeBitSetSegments(numSegmentsToPreallocate, numLongsPerSegment));
}
public void set(int position) {
int segmentPosition = position >>> log2SegmentSize; /// which segment -- div by num bits per segment
int longPosition = (position >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
int bitPosition = position & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)
AtomicLongArray segment = getSegment(segmentPosition);
long mask = 1L << bitPosition;
// Thread safety: we need to loop until we win the race to set the long value.
while(true) {
// determine what the new long value will be after we set the appropriate bit.
long currentLongValue = segment.get(longPosition);
long newLongValue = currentLongValue | mask;
// if no other thread has modified the value since we read it, we won the race and we are done.
if(segment.compareAndSet(longPosition, currentLongValue, newLongValue))
break;
}
}
public void clear(int position) {
int segmentPosition = position >>> log2SegmentSize; /// which segment -- div by num bits per segment
int longPosition = (position >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
int bitPosition = position & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)
AtomicLongArray segment = getSegment(segmentPosition);
long mask = ~(1L << bitPosition);
// Thread safety: we need to loop until we win the race to set the long value.
while(true) {
// determine what the new long value will be after we set the appropriate bit.
long currentLongValue = segment.get(longPosition);
long newLongValue = currentLongValue & mask;
// if no other thread has modified the value since we read it, we won the race and we are done.
if(segment.compareAndSet(longPosition, currentLongValue, newLongValue))
break;
}
}
public boolean get(int position) {
int segmentPosition = position >>> log2SegmentSize; /// which segment -- div by num bits per segment
int longPosition = (position >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
int bitPosition = position & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)
AtomicLongArray segment = getSegment(segmentPosition);
long mask = 1L << bitPosition;
return ((segment.get(longPosition) & mask) != 0);
}
public long maxSetBit() {
ThreadSafeBitSetSegments segments = this.segments.get();
int segmentIdx = segments.numSegments() - 1;
for(;segmentIdx >= 0; segmentIdx--) {
AtomicLongArray segment = segments.getSegment(segmentIdx);
for(int longIdx=segment.length() - 1; longIdx >= 0; longIdx--) {
long l = segment.get(longIdx);
if(l != 0)
return (segmentIdx << log2SegmentSize) + (longIdx * 64) + (63 - Long.numberOfLeadingZeros(l));
}
}
return -1;
}
public int nextSetBit(int fromIndex) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);
int segmentPosition = fromIndex >>> log2SegmentSize; /// which segment -- div by num bits per segment
ThreadSafeBitSetSegments segments = this.segments.get();
if(segmentPosition >= segments.numSegments())
return -1;
int longPosition = (fromIndex >>> 6) & segmentMask; /// which long in the segment -- remainder of div by num bits per segment
int bitPosition = fromIndex & 0x3F; /// which bit in the long -- remainder of div by num bits in long (64)
AtomicLongArray segment = segments.getSegment(segmentPosition);
long word = segment.get(longPosition) & (0xffffffffffffffffL << bitPosition);
while (true) {
if (word != 0)
return (segmentPosition << (log2SegmentSize)) + (longPosition << 6) + Long.numberOfTrailingZeros(word);
if (++longPosition > segmentMask) {
segmentPosition++;
if(segmentPosition >= segments.numSegments())
return -1;
segment = segments.getSegment(segmentPosition);
longPosition = 0;
}
word = segment.get(longPosition);
}
}
/**
* @return the number of bits which are set in this bit set.
*/
public int cardinality() {
ThreadSafeBitSetSegments segments = this.segments.get();
int numSetBits = 0;
for(int i=0;i<segments.numSegments();i++) {
AtomicLongArray segment = segments.getSegment(i);
for(int j=0;j<segment.length();j++) {
numSetBits += Long.bitCount(segment.get(j));
}
}
return numSetBits;
}
/**
* @return the number of bits which are current specified by this bit set. This is the maximum value
* to which you might need to iterate, if you were to iterate over all bits in this set.
*/
public int currentCapacity() {
return segments.get().numSegments() * (1 << log2SegmentSize);
}
/**
* Clear all bits to 0.
*/
public void clearAll() {
ThreadSafeBitSetSegments segments = this.segments.get();
for(int i=0;i<segments.numSegments();i++) {
AtomicLongArray segment = segments.getSegment(i);
for(int j=0;j<segment.length();j++) {
segment.set(j, 0L);
}
}
}
/**
* Return a new bit set which contains all bits which are contained in this bit set, and which are NOT contained in the <code>other</code> bit set.<p>
*
* In other words, return a new bit set, which is a bitwise and with the bitwise not of the other bit set.
*
* @param other the other bit set
* @return the resulting bit set
*/
public ThreadSafeBitSet andNot(ThreadSafeBitSet other) {
if(other.log2SegmentSize != log2SegmentSize)
throw new IllegalArgumentException("Segment sizes must be the same");
ThreadSafeBitSetSegments thisSegments = this.segments.get();
ThreadSafeBitSetSegments otherSegments = other.segments.get();
ThreadSafeBitSetSegments newSegments = new ThreadSafeBitSetSegments(thisSegments.numSegments(), numLongsPerSegment);
for(int i=0;i<thisSegments.numSegments();i++) {
AtomicLongArray thisArray = thisSegments.getSegment(i);
AtomicLongArray otherArray = (i < otherSegments.numSegments()) ? otherSegments.getSegment(i) : null;
AtomicLongArray newArray = newSegments.getSegment(i);
for(int j=0;j<thisArray.length();j++) {
long thisLong = thisArray.get(j);
long otherLong = (otherArray == null) ? 0 : otherArray.get(j);
newArray.set(j, thisLong & ~otherLong);
}
}
ThreadSafeBitSet andNot = new ThreadSafeBitSet(log2SegmentSize);
andNot.segments.set(newSegments);
return andNot;
}
/**
* Return a new bit set which contains all bits which are contained in *any* of the specified bit sets.
*
* @param bitSets the other bit sets
* @return the resulting bit set
*/
public static ThreadSafeBitSet orAll(ThreadSafeBitSet... bitSets) {
if(bitSets.length == 0)
return new ThreadSafeBitSet();
int log2SegmentSize = bitSets[0].log2SegmentSize;
int numLongsPerSegment = bitSets[0].numLongsPerSegment;
ThreadSafeBitSetSegments segments[] = new ThreadSafeBitSetSegments[bitSets.length];
int maxNumSegments = 0;
for(int i=0;i<bitSets.length;i++) {
if(bitSets[i].log2SegmentSize != log2SegmentSize)
throw new IllegalArgumentException("Segment sizes must be the same");
segments[i] = bitSets[i].segments.get();
if(segments[i].numSegments() > maxNumSegments)
maxNumSegments = segments[i].numSegments();
}
ThreadSafeBitSetSegments newSegments = new ThreadSafeBitSetSegments(maxNumSegments, numLongsPerSegment);
AtomicLongArray segment[] = new AtomicLongArray[segments.length];
for(int i=0;i<maxNumSegments;i++) {
for(int j=0;j<segments.length;j++) {
segment[j] = i < segments[j].numSegments() ? segments[j].getSegment(i) : null;
}
AtomicLongArray newSegment = newSegments.getSegment(i);
for(int j=0;j<numLongsPerSegment;j++) {
long value = 0;
for(int k=0;k<segments.length;k++) {
if(segment[k] != null)
value |= segment[k].get(j);
}
newSegment.set(j, value);
}
}
ThreadSafeBitSet or = new ThreadSafeBitSet(log2SegmentSize);
or.segments.set(newSegments);
return or;
}
/**
* Get the segment at <code>segmentIndex</code>. If this segment does not yet exist, create it.
*
* @param segmentIndex the segment index
* @return the segment
*/
private AtomicLongArray getSegment(int segmentIndex) {
ThreadSafeBitSetSegments visibleSegments = segments.get();
while(visibleSegments.numSegments() <= segmentIndex) {
/// Thread safety: newVisibleSegments contains all of the segments from the currently visible segments, plus extra.
/// all of the segments in the currently visible segments are canonical and will not change.
ThreadSafeBitSetSegments newVisibleSegments = new ThreadSafeBitSetSegments(visibleSegments, segmentIndex + 1, numLongsPerSegment);
/// because we are using a compareAndSet, if this thread "wins the race" and successfully sets this variable, then the segments
/// which are newly defined in newVisibleSegments become canonical.
if(segments.compareAndSet(visibleSegments, newVisibleSegments)) {
visibleSegments = newVisibleSegments;
} else {
/// If we "lose the race" and are growing the ThreadSafeBitSet segments larger,
/// then we will gather the new canonical sets from the update which we missed on the next iteration of this loop.
/// Newly defined segments in newVisibleSegments will be discarded, they do not get to become canonical.
visibleSegments = segments.get();
}
}
return visibleSegments.getSegment(segmentIndex);
}
private static class ThreadSafeBitSetSegments {
private final AtomicLongArray segments[];
private ThreadSafeBitSetSegments(int numSegments, int segmentLength) {
AtomicLongArray segments[] = new AtomicLongArray[numSegments];
for(int i=0;i<numSegments;i++) {
segments[i] = new AtomicLongArray(segmentLength);
}
/// Thread safety: Because this.segments is final, the preceding operations in this constructor are guaranteed to be visible to any
/// other thread which accesses this.segments.
this.segments = segments;
}
private ThreadSafeBitSetSegments(ThreadSafeBitSetSegments copyFrom, int numSegments, int segmentLength) {
AtomicLongArray segments[] = new AtomicLongArray[numSegments];
for(int i=0;i<numSegments;i++) {
segments[i] = i < copyFrom.numSegments() ? copyFrom.getSegment(i) : new AtomicLongArray(segmentLength);
}
/// see above re: thread-safety of this assignment
this.segments = segments;
}
public int numSegments() {
return segments.length;
}
public AtomicLongArray getSegment(int index) {
return segments[index];
}
}
public void serializeBitsTo(DataOutputStream os) throws IOException {
ThreadSafeBitSetSegments segments = this.segments.get();
os.writeInt(segments.numSegments() * numLongsPerSegment);
for(int i=0;i<segments.numSegments();i++) {
AtomicLongArray arr = segments.getSegment(i);
for(int j=0;j<arr.length();j++) {
os.writeLong(arr.get(j));
}
}
}
@Override
public boolean equals(Object obj) {
if(!(obj instanceof ThreadSafeBitSet))
return false;
ThreadSafeBitSet other = (ThreadSafeBitSet)obj;
if(other.log2SegmentSize != log2SegmentSize)
throw new IllegalArgumentException("Segment sizes must be the same");
ThreadSafeBitSetSegments thisSegments = this.segments.get();
ThreadSafeBitSetSegments otherSegments = other.segments.get();
for(int i=0;i<thisSegments.numSegments();i++) {
AtomicLongArray thisArray = thisSegments.getSegment(i);
AtomicLongArray otherArray = (i < otherSegments.numSegments()) ? otherSegments.getSegment(i) : null;
for(int j=0;j<thisArray.length();j++) {
long thisLong = thisArray.get(j);
long otherLong = (otherArray == null) ? 0 : otherArray.get(j);
if(thisLong != otherLong)
return false;
}
}
for(int i=thisSegments.numSegments();i<otherSegments.numSegments();i++) {
AtomicLongArray otherArray = otherSegments.getSegment(i);
for(int j=0;j<otherArray.length();j++) {
long l = otherArray.get(j);
if(l != 0)
return false;
}
}
return true;
}
@Override
public int hashCode() {
int result = log2SegmentSize;
result = 31 * result + Arrays.hashCode(segments.get().segments);
return result;
}
/**
* @return a new BitSet with same bits set
*/
public BitSet toBitSet() {
BitSet resultSet = new BitSet();
int ordinal = this.nextSetBit(0);
while(ordinal!=-1) {
resultSet.set(ordinal);
ordinal = this.nextSetBit(ordinal + 1);
}
return resultSet;
}
@Override
public String toString() {
return toBitSet().toString();
}
}
+1 -1
View File
@@ -20,7 +20,7 @@ buildscript {
}
}
dependencies {
classpath "com.github.GTNH2:ForgeGradle:FG_1.2-SNAPSHOT"
classpath 'com.github.GTNewHorizons:ForgeGradle:1.2.4'
}
}