static string BenchmarkGrowingTreeWrite(int acountCount, int range, int runs, int warmUpRuns)
{
var rand = new Random();
List <Action> actions = null;
Action stepUp = () =>
{
var tree = new RawConcurrentIndexed <int, int>();
actions = new List <Action>();
for (int i = 0; i < acountCount; i++)
{
var number = rand.Next(range);
actions.Add(() =>
{
tree.GetOrAdd(number, number);
});
}
};
Action run = () =>
{
Parallel.Invoke(actions.ToArray());
};
return(MyStupidBenchmarker.Benchmark(stepUp, run, runs, warmUpRuns).ToString());
}
public void Setup()
{
//tree = new RawConcurrentIndexedTree<Guid, Guid>();
growning = new RawConcurrentIndexed <Guid, Guid>();
concurrentDictionary = new ConcurrentDictionary <Guid, Guid>();
//origninal = new RawConcurrentIndexed<Guid, Guid>();
}
static string BenchmarkGrowingTreeRead(int acountCount, int runs, int warmUpRuns)
{
var rand = new Random();
List <Action> actions = null;
Action stepUp = () =>
{
var tree = new RawConcurrentIndexed <Guid, string>();
actions = new List <Action>();
for (int i = 0; i < acountCount; i++)
{
var guid = Guid.NewGuid();
tree.GetOrAdd(guid, guid.ToString());
actions.Add(() =>
{
tree.TryGetValue(guid, out var _);
});
}
};
Action run = () =>
{
Parallel.Invoke(actions.ToArray());
};
return(MyStupidBenchmarker.Benchmark(stepUp, run, runs, warmUpRuns).ToString());
}
public static void Handle(this GameState gameState, GameStateUpdate gameStateUpdate)
{
gameState.Frame = gameStateUpdate.Frame;
gameState.GameBall = gameStateUpdate.Ball;
var nextCollisions = new ConcurrentLinkedList <Collision>();
foreach (var item in gameStateUpdate.Collisions)
{
nextCollisions.Add(item);
}
gameState.collisions = nextCollisions;
gameState.CountDownState = gameStateUpdate.CountDownState;
var nextGoalsScores = new ConcurrentLinkedList <GoalScored>();
foreach (var item in gameStateUpdate.GoalsScored)
{
nextGoalsScores.Add(item);
}
gameState.GoalsScored = nextGoalsScores;
var nextPlayers = new RawConcurrentIndexed <Guid, Player>();
foreach (var item in gameStateUpdate.Players)
{
nextPlayers.TryAdd(item.Id, item);
}
gameState.players = nextPlayers;
gameState.RightScore = gameStateUpdate.RightScore;
gameState.LeftScore = gameStateUpdate.LeftScore;
}
public void Add()
{
var thing = new RawConcurrentIndexed <string, string>();
var str = Guid.NewGuid().ToString();
thing.GetOrAdd(str, str);
Assert.Equal(str, thing[str]);
}
public void Setup()
{
thing = new RawConcurrentIndexed <SimpleHash, string>(2);
simpleHash0 = new SimpleHash(0b_0000_00_00_00_00_00_00_00_00_00_00_00_00_00_00);
thing.GetOrAdd(simpleHash0, "0-0");
simpleHash1 = new SimpleHash(0b_0001_01_00_00_00_00_00_00_00_00_00_00_00_00_00);
thing.GetOrAdd(new SimpleHash(0b_0001_00_00_00_00_00_00_00_00_00_00_00_00_00_00), "1-0");
thing.GetOrAdd(simpleHash1, "1-1");
simpleHashNot = new SimpleHash(0b_0010_01_00_01_00_00_10_00_00_00_00_00_00_00_00);
//simpleHash2 = new SimpleHash(0b_0010_10_00_00_00_00_00_00_00_00_00_00_00_00_00);
//thing.GetOrAdd(new SimpleHash(0b_0010_00_00_00_00_00_00_00_00_00_00_00_00_00_00), "2-0");
//thing.GetOrAdd(new SimpleHash(0b_0010_01_00_00_00_00_00_00_00_00_00_00_00_00_00), "2-1");
//thing.GetOrAdd(simpleHash2, "1-2");
}
public void Growing3AddAndGetBackParallel()
{
for (int n = 0; n < 100; n++)
{
var thing = new RawConcurrentIndexed <string, string>();
var toAdds = new string[10000];
for (int i = 0; i < toAdds.Length; i++)
{
toAdds[i] = Guid.NewGuid().ToString();
}
Parallel.Invoke(toAdds.Select <string, Action>(x =>
() => thing.GetOrAdd(x, x)).ToArray());
Parallel.Invoke(toAdds.Select <string, Action>(x =>
() => Assert.Equal(x, thing[x])).ToArray());
}
}
public void GrowingAddAndGetBack()
{
var thing = new RawConcurrentIndexed <string, string>();
var toAdds = new string[1000];
for (int i = 0; i < toAdds.Length; i++)
{
toAdds[i] = Guid.NewGuid().ToString();
}
foreach (var toAdd in toAdds)
{
thing.GetOrAdd(toAdd, toAdd);
}
foreach (var toAdd in toAdds)
{
Assert.Equal(toAdd, thing[toAdd]);
}
}
public void RawAddAndRemove()
{
var random = new Random();
for (int i = 0; i < 10000; i++)
{
const int V = 1000;
var check = new int[V];
var thing = new RawConcurrentIndexed <int, string>();
int count = 0;
Parallel.Invoke(new int[10000].Select <int, Action>(_ => () => {
var value = random.Next(1000);
if (random.Next(2) == 1)
{
if (thing.TryAdd(value, value.ToString()))
{
Interlocked.Increment(ref check[value]);
Interlocked.Increment(ref count);
}
}
else
{
if (thing.TryRemove(value, out var _))
{
Interlocked.Decrement(ref check[value]);
Interlocked.Decrement(ref count);
}
}
}).ToArray());
Assert.Equal(count, thing.Count);
for (int j = 0; j < V; j++)
{
Assert.Equal(check[j] > 0, thing.ContainsKey(j));
}
foreach (var item in thing)
{
Assert.True(check[item.Key] > 0);
}
}
}
public void Setup()
{
//thing = new ConcurrentDictionary<Guid, string>();
thing = new RawConcurrentIndexed <Guid, string>(sizeInBit);
items = new List <List <Guid> >();
for (var x = 0; x < Threads; x++)
{
var myList = new List <Guid>();
for (var y = 0; y < Items; y++)
{
var guid = Guid.NewGuid();
thing.GetOrAdd(guid, guid.ToString());
myList.Add(guid);
}
items.Add(myList);
}
Task.Delay(2000).Wait();
}
