public void TestSingleThreadContains()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var idList = ConstructIdList(10000);
Parallel.ForEach(idList, x => list.Add(new Order {
Id = x, Name = x.ToString()
}));
foreach (var i in idList)
{
Assert.True(list.Contains(new Order {
Id = i, Name = i.ToString()
}));
}
var random = new Random((int)DateTime.Now.Ticks & 0x0000ffff);
for (var i = 0; i < 20; i++)
{
var rand = random.Next();
if (!idList.Contains(rand))
{
Assert.False(list.Contains(new Order {
Id = rand, Name = rand.ToString()
}));
}
}
}
public void TestMultithreadRemoveAndContains()
{
var list = new ConcurrentSortedList <int>();
var idList = Enumerable.Range(0, 10000).ToList();
Parallel.ForEach(idList, x => list.Add(x));
Parallel.ForEach(idList, x =>
{
if (x < 5000)
{
Assert.True(list.Remove(x));
}
else
{
Assert.True(list.Contains(x));
}
});
Assert.Equal(5000, list.Count);
for (var i = 0; i < 5000; i++)
{
Assert.False(list.Contains(idList[i]));
}
AssertIntList(list, 5000);
}
public void TestParallelMixedAddAndRemove()
{
var list = new ConcurrentSortedList <int>();
var prepare = Enumerable.Range(0, 10000).Select(x => x * 2).ToList();
Parallel.ForEach(prepare, x => list.Add(x));
var tasks = new Task[4000];
for (var i = 0; i < 2000; i++)
{
var id = i;
tasks[i] = new Task(() => Assert.True(list.Remove(id * 2)));
}
for (var i = 0; i < 2000; i++)
{
var id = i;
tasks[i + 2000] = new Task(() => list.Add(id * 2 + 1));
}
Parallel.ForEach(tasks, x => x.Start());
Task.WaitAll(tasks);
Assert.Equal(10000, list.Count);
foreach (var i in list)
{
if (i < 4000)
{
Assert.Equal(1, i % 2);
}
else
{
Assert.Equal(0, i % 2);
}
}
AssertIntList(list, 10000);
}
public void TestSingleThreadRemove()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var idList = ConstructIdList(10000);
Parallel.ForEach(idList, x => list.Add(new Order {
Id = x, Name = x.ToString()
}));
for (var i = 0; i < 1000; i++)
{
Assert.True(list.Remove(new Order {
Id = idList[i], Name = idList[i].ToString()
}));
}
Assert.Equal(9000, list.Count);
for (var i = 0; i < 1000; i++)
{
Assert.False(list.Contains(new Order {
Id = idList[i], Name = idList[i].ToString()
}));
}
for (var i = 0; i < 9000; i++)
{
Assert.True(list.Contains(new Order {
Id = idList[i + 1000], Name = idList[i + 1000].ToString()
}));
}
AssertOrderList(list, 9000);
}
public void BinarySearchTest()
{
int a, b;
var csl = new ConcurrentSortedList();
(a, b) = csl.BinarySearch(1);
Assert.Equal(-1, a);
Assert.Equal(0, b);
csl.Add(1);
(a, b) = csl.BinarySearch(1);
Assert.Equal(0, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(0);
Assert.Equal(-1, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(100);
Assert.Equal(csl.Count - 1, a);
Assert.Equal(csl.Count, b);
csl.Add(2);
(a, b) = csl.BinarySearch(1);
Assert.Equal(0, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(2);
Assert.Equal(1, a);
Assert.Equal(1, b);
(a, b) = csl.BinarySearch(0);
Assert.Equal(-1, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(100);
Assert.Equal(csl.Count - 1, a);
Assert.Equal(csl.Count, b);
csl.Add(4);
(a, b) = csl.BinarySearch(1);
Assert.Equal(0, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(2);
Assert.Equal(1, a);
Assert.Equal(1, b);
(a, b) = csl.BinarySearch(4);
Assert.Equal(2, a);
Assert.Equal(2, b);
(a, b) = csl.BinarySearch(0);
Assert.Equal(-1, a);
Assert.Equal(0, b);
(a, b) = csl.BinarySearch(100);
Assert.Equal(csl.Count - 1, a);
Assert.Equal(csl.Count, b);
(a, b) = csl.BinarySearch(3);
Assert.Equal(1, a);
Assert.Equal(2, b);
}
public void AddAndContainsTest()
{
var csl = new ConcurrentSortedList();
Assert.Equal(0, csl.Count);
Assert.False(csl.Contains(12));
csl.Add(12);
Assert.Equal(1, csl.Count);
Assert.True(csl.Contains(12));
Assert.False(csl.Contains(15));
csl.Add(15);
Assert.Equal(2, csl.Count);
Assert.True(csl.Contains(12));
Assert.True(csl.Contains(15));
Assert.False(csl.Contains(5));
csl.Add(5);
Assert.Equal(3, csl.Count);
Assert.True(csl.Contains(12));
Assert.True(csl.Contains(15));
Assert.True(csl.Contains(5));
Assert.False(csl.Contains(13));
Assert.Equal((UInt64)5, csl[0]);
Assert.Equal((UInt64)15, csl[2]);
Assert.Equal((UInt64)12, csl[1]);
csl.Add(12); // repeat
Assert.Equal(3, csl.Count);
Assert.True(csl.Contains(12));
Assert.True(csl.Contains(15));
Assert.True(csl.Contains(5));
Assert.False(csl.Contains(13));
Assert.Equal((UInt64)5, csl[0]);
Assert.Equal((UInt64)12, csl[1]);
Assert.Equal((UInt64)15, csl[2]);
csl.Add(13);
Assert.Equal(4, csl.Count);
Assert.True(csl.Contains(12));
Assert.True(csl.Contains(15));
Assert.True(csl.Contains(5));
Assert.True(csl.Contains(13));
Assert.False(csl.Contains(100)); // random
Assert.Equal((UInt64)5, csl[0]);
Assert.Equal((UInt64)12, csl[1]);
Assert.Equal((UInt64)13, csl[2]);
Assert.Equal((UInt64)15, csl[3]);
}
static void Main(string[] args)
{
var list = new ConcurrentSortedList();
//var list = new SynchronizedSortedList();
var random = new Random();
var testThreads = Enumerable.Range(0, 2).Select(_ => new Thread(() =>
{
for (int j = 0; j < 10000; ++j)
{
list.Insert(random.Next());
}
})).ToList();
var countingThread = new Thread(() =>
{
try
{
while (true)
{
Thread.Sleep(0);
Console.WriteLine($"\r{list.Size()}");
Console.Out.FlushAsync();
}
}
catch (ThreadInterruptedException)
{
}
});
var start = DateTime.Now;
testThreads.ForEach(t => t.Start());
countingThread.Start();
testThreads.ForEach(t => t.Join());
countingThread.Interrupt();
Console.WriteLine($"\rElapsed: {DateTime.Now - start}");
Console.WriteLine($"\r{list.Size()}");
if (list.Size() != 20000)
{
Console.WriteLine("*** Wrong size!");
}
if (!list.IsSorted())
{
Console.WriteLine("*** Not sorted!");
}
}
public void TestMultithreadRemoveAndThenEnumerate()
{
var list = new ConcurrentSortedList <int>();
var idList = Enumerable.Range(0, 10000).ToList();
var removeList = Enumerable.Range(0, 5000).Select(x => x * 2).ToList();
Parallel.ForEach(idList, x => list.Add(x));
Parallel.ForEach(removeList, x => list.Remove(x));
Assert.Equal(5000, list.Count);
foreach (var i in list)
{
Assert.Equal(1, i % 2);
}
AssertIntList(list, 5000);
}
public void TestSingleThreadAdd()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var random = new Random((int)DateTime.Now.Ticks & 0x0000ffff);
for (var i = 0; i < 10000; i++)
{
var number = random.Next();
var order = new Order {
Id = number, Name = number.ToString()
};
list.Add(order);
}
AssertOrderList(list, 10000);
}
public void TestParallelAdd()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var random = new Random((int)DateTime.Now.Ticks & 0x0000ffff);
var idList = new List <int>();
for (var i = 0; i < 10000; i++)
{
idList.Add(random.Next());
}
Parallel.ForEach(idList, x => list.Add(new Order {
Id = x, Name = x.ToString()
}));
AssertOrderList(list, 10000);
}
private void AssertOrderList(ConcurrentSortedList <Order> list, int number)
{
Assert.Equal(number, list.Count);
var orders = new Order[number];
var cursor = 0;
foreach (var i in list)
{
orders[cursor] = i;
cursor++;
}
for (var i = 1; i < number; i++)
{
Assert.True(orders[i - 1].Id <= orders[i].Id);
}
}
private void AssertIntList(ConcurrentSortedList <int> list, int number)
{
Assert.Equal(number, list.Count);
var items = new int[number];
var cursor = 0;
foreach (var i in list)
{
items[cursor] = i;
cursor++;
}
for (var i = 1; i < number; i++)
{
Assert.True(items[i - 1] <= items[i]);
}
}
public MusicLoader(string syncDir, string token, long userId)
{
DependencyUtility.BuildUp(this);
syncDirectory = syncDir;
this.userId = userId;
api = new VkApi();
api.Authorize(token, userId);
api.Invoke("stats.trackVisitor", new Dictionary<string, string>(), true); // статистика посещаемости приложения
remoteAudioSizeHelper = new RemoteAudioSizeHelper(Path.Combine(AppPaths.SettingsPath, "sizes.dat"));
tracks = new ConcurrentSortedList<int, Track>();
int key = 0;
foreach (var track in TrackRepository.GetTracks())
tracks.Add(key++, track);
}
public void TestSingleThreadAddDuplicate()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var idList = ConstructIdList(10000);
Parallel.ForEach(idList, x => list.Add(new Order {
Id = x, Name = x.ToString()
}));
var tasks = new Task[1000];
for (var i = 0; i < 1000; i++)
{
var id = i;
tasks[i] = Task.Factory.StartNew(() => list.Add(new Order {
Id = id, Name = id.ToString()
}));
}
Task.WaitAll(tasks);
Assert.Equal(11000, list.Count);
AssertOrderList(list, 11000);
}
public void ConcurrentSortedListAdd_InParallel_CorreclyAddedItems_Test()
{
var csl = new ConcurrentSortedList<int, string>();
var list = new List<string>
{
"4",
"2",
"7",
"5",
"1"
};
Parallel.ForEach(list, item => csl.Add(int.Parse(item), item));
Assert.Equal(5, csl.Count);
Assert.Equal("1",csl.Values[0]);
Assert.Equal("2", csl.Values[1]);
Assert.Equal("4", csl.Values[2]);
Assert.Equal("5", csl.Values[3]);
Assert.Equal("7", csl.Values[4]);
}
public void ConcurrentSortedListAdd_InParallel_CorreclyAddedItems_Test()
{
var csl = new ConcurrentSortedList <int, string>();
var list = new List <string>
{
"4",
"2",
"7",
"5",
"1"
};
Parallel.ForEach(list, item => csl.Add(int.Parse(item), item));
Assert.AreEqual(5, csl.Count);
Assert.AreEqual("1", csl.Values[0]);
Assert.AreEqual("2", csl.Values[1]);
Assert.AreEqual("4", csl.Values[2]);
Assert.AreEqual("5", csl.Values[3]);
Assert.AreEqual("7", csl.Values[4]);
}
public void TestMultithreadAddAndReomove()
{
var list = new ConcurrentSortedList <int>();
var idList = Enumerable.Range(0, 10000).ToList();
var newIdList = Enumerable.Range(10000, 2000).ToList();
Parallel.ForEach(idList, x => list.Add(x));
var tasks = new Task[3000];
for (var i = 0; i < 2000; i++)
{
var id = newIdList[i];
tasks[i] = new Task(() => list.Add(id));
}
for (var i = 0; i < 1000; i++)
{
var id = idList[i];
tasks[i + 2000] = new Task(() => list.Remove(id));
}
Parallel.ForEach(tasks, x => x.Start());
Task.WaitAll(tasks);
Assert.Equal(11000, list.Count);
for (var i = 0; i < 2000; i++)
{
Assert.True(list.Contains(newIdList[i]));
}
for (var i = 0; i < 1000; i++)
{
Assert.False(list.Contains(idList[i]));
}
for (var i = 0; i < 9000; i++)
{
Assert.True(list.Contains(idList[i + 1000]));
}
AssertIntList(list, 11000);
}
public void TestMultithreadAdd()
{
var list = new ConcurrentSortedList <Order>(new OrderComparer());
var tasks = new Task[10000];
var random = new Random((int)DateTime.Now.Ticks & 0x0000ffff);
for (var i = 0; i < 10000; i++)
{
tasks[i] = Task.Factory.StartNew(() =>
{
var id = 0;
lock (locker)
{
id = random.Next();
}
list.Add(new Order {
Id = id, Name = id.ToString()
});
});
}
Task.WaitAll(tasks);
AssertOrderList(list, 10000);
}
public void ConcurrentSortedListCount_InParallel_CorreclyGetCount_Test()
{
var csl = new ConcurrentSortedList<int, string>();
var list = new List<string>
{
"4",
"2",
"7",
"5",
"1"
};
int count = 0;
Parallel.ForEach(list, item => csl.Add(int.Parse(item), item));
Parallel.ForEach(csl.Values, i =>
{
count = csl.Count;
});
Assert.Equal(5,count);
}
public void ConcurrentSortedListCount_InParallel_CorreclyGetCount_Test()
{
var csl = new ConcurrentSortedList <int, string>();
var list = new List <string>
{
"4",
"2",
"7",
"5",
"1"
};
int count = 0;
Parallel.ForEach(list, item => csl.Add(int.Parse(item), item));
Parallel.ForEach(csl.Values, i =>
{
count = csl.Count;
});
Assert.AreEqual(5, count);
}
public void TestMultithreadAddAndContains()
{
var list = new ConcurrentSortedList <int>();
var idList = Enumerable.Range(0, 5000).ToList();
Parallel.ForEach(idList, x => list.Add(x));
var newIdList = Enumerable.Range(5000, 5000).ToList();
var tasks = new Task[10000];
for (var i = 0; i < 5000; i++)
{
var id = newIdList[i];
tasks[i] = new Task(() => list.Add(id));
}
for (var i = 0; i < 5000; i++)
{
var id = i;
tasks[i + 5000] = new Task(() => Assert.True(list.Contains(id)));
}
Parallel.ForEach(tasks, x => x.Start());
Task.WaitAll(tasks);
Assert.Equal(10000, list.Count);
AssertIntList(list, 10000);
}
private void Load()
{
if (!Monitor.TryEnter(musicLoadLock))
return;
OnSynchronizationStarted();
var audios = api.Audio.Get(userId);
OnProgressChanged(new ProgressStatus { TotalCount = audios.Count });
var addedList = new List<Track>();
var trackIDs = tracks.Values.Select(t => t.Id).ToList();
var tracksCount = tracks.Count;
tracks = new ConcurrentSortedList<int, Track>();
int loadedTracksCount = 0;
var tracksDictionary = audios.ToDictionary(audio => audio, audio => new Track().Update(audio));
var trackIndexes = tracksDictionary.Values.Select((s, i) => new { s, i }).ToDictionary(x => x.s, x => x.i);
Parallel.ForEach(audios, new ParallelOptions { MaxDegreeOfParallelism = 4 }, (audio) =>
{
var track = tracksDictionary[audio];
var fileName = track.GetFilePath();
var fi = new FileInfo(fileName);
if (remoteAudioSizeHelper.GetSize(audio) > 0)
{
if (!trackIDs.Contains(audio.Id))
{
addedList.Add(track);
}
if (!fi.Exists || fi.Length < remoteAudioSizeHelper.GetSize(audio))
{
TrySaveFileFromUrl(audio.Url.ToString(), fileName);
}
tracks.Add(trackIndexes[track], track);
OnAddedOneTrack(track, tracks.Values.ToList());
Interlocked.Increment(ref loadedTracksCount);
OnProgressChanged(new ProgressStatus { TotalCount = audios.Count, DoneCount = loadedTracksCount });
}
});
remoteAudioSizeHelper.Save();
TrackRepository.SaveTracks(tracks.Values.ToList());
// TODO do we really need deleted list?
var deletedList = GetDeletedTrackIDs();
OnCompleted();
lastLoadTime = DateTime.UtcNow;
Monitor.Exit(musicLoadLock);
}
