|
|
using Implab.Formats.Json;
|
|
|
using Implab.Parallels;
|
|
|
using Implab.Xml;
|
|
|
using System;
|
|
|
using System.Collections.Concurrent;
|
|
|
using System.Collections.Generic;
|
|
|
using System.IO;
|
|
|
using System.Linq;
|
|
|
using System.Text;
|
|
|
using System.Threading;
|
|
|
using System.Threading.Tasks;
|
|
|
using System.Xml;
|
|
|
using System.Xml.Serialization;
|
|
|
|
|
|
namespace Implab.Playground {
|
|
|
public class Program {
|
|
|
|
|
|
static void EnqueueRange<T>(ConcurrentQueue<T> q, T[] data, int offset, int len) {
|
|
|
for (var i = offset; i < offset + len; i++)
|
|
|
q.Enqueue(data[i]);
|
|
|
}
|
|
|
|
|
|
static bool TryDequeueRange<T>(ConcurrentQueue<T> q,T[] buffer,int offset, int len, out int actual) {
|
|
|
actual = 0;
|
|
|
T res;
|
|
|
while(q.TryDequeue(out res)) {
|
|
|
buffer[offset + actual] = res;
|
|
|
actual++;
|
|
|
if (actual == len)
|
|
|
break;
|
|
|
}
|
|
|
return actual != 0;
|
|
|
}
|
|
|
|
|
|
static void EnqueueRange<T>(SimpleAsyncQueue<T> q, T[] data, int offset, int len) {
|
|
|
for (var i = offset; i < offset + len; i++)
|
|
|
q.Enqueue(data[i]);
|
|
|
}
|
|
|
|
|
|
static bool TryDequeueRange<T>(SimpleAsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
|
|
|
actual = 0;
|
|
|
T res;
|
|
|
while (q.TryDequeue(out res)) {
|
|
|
buffer[offset + actual] = res;
|
|
|
actual++;
|
|
|
if (actual == len)
|
|
|
break;
|
|
|
}
|
|
|
return actual != 0;
|
|
|
}
|
|
|
|
|
|
static void EnqueueRange<T>(AsyncQueue<T> q, T[] data, int offset, int len) {
|
|
|
for (var i = offset; i < offset + len; i++)
|
|
|
q.Enqueue(data[i]);
|
|
|
}
|
|
|
|
|
|
static bool TryDequeueRange<T>(AsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
|
|
|
actual = 0;
|
|
|
T res;
|
|
|
while (q.TryDequeue(out res)) {
|
|
|
buffer[offset + actual] = res;
|
|
|
actual++;
|
|
|
if (actual == len)
|
|
|
break;
|
|
|
}
|
|
|
return actual != 0;
|
|
|
}
|
|
|
|
|
|
|
|
|
/*static void EnqueueRange<T>(AsyncQueue<T> q, T[] data, int offset, int len) {
|
|
|
q.EnqueueRange(data, offset, len);
|
|
|
}
|
|
|
|
|
|
static bool TryDequeueRange<T>(AsyncQueue<T> q, T[] buffer, int offset, int len, out int actual) {
|
|
|
return q.TryDequeueRange(buffer, offset, len, out actual);
|
|
|
}*/
|
|
|
|
|
|
|
|
|
static void Main(string[] args) {
|
|
|
|
|
|
//var queue = new ConcurrentQueue<int>();
|
|
|
var queue = new AsyncQueue<int>();
|
|
|
//var queue = new SimpleAsyncQueue<int>();
|
|
|
|
|
|
const int wBatch = 32;
|
|
|
const long wCount = 1000000;
|
|
|
const long total = wBatch * wCount * 3;
|
|
|
|
|
|
long r1 = 0, r2 = 0, r3 = 0;
|
|
|
const int rBatch = 1000;
|
|
|
long read = 0;
|
|
|
|
|
|
var t1 = Environment.TickCount;
|
|
|
|
|
|
AsyncPool.RunThread(
|
|
|
() => {
|
|
|
var buffer = new int[wBatch];
|
|
|
for (int i = 0; i < wBatch; i++)
|
|
|
buffer[i] = 1;
|
|
|
|
|
|
for (int i = 0; i < wCount; i++)
|
|
|
EnqueueRange(queue, buffer, 0, wBatch);
|
|
|
Console.WriteLine("done writer #1: {0} ms", Environment.TickCount - t1);
|
|
|
},
|
|
|
() => {
|
|
|
var buffer = new int[wBatch];
|
|
|
for (int i = 0; i < wBatch; i++)
|
|
|
buffer[i] = 1;
|
|
|
|
|
|
for (int i = 0; i < wCount; i++)
|
|
|
EnqueueRange(queue, buffer, 0, wBatch);
|
|
|
Console.WriteLine("done writer #2: {0} ms", Environment.TickCount - t1);
|
|
|
},
|
|
|
() => {
|
|
|
var buffer = new int[wBatch];
|
|
|
for (int i = 0; i < wBatch; i++)
|
|
|
buffer[i] = 1;
|
|
|
|
|
|
for (int i = 0; i < wCount; i++)
|
|
|
EnqueueRange(queue, buffer, 0, wBatch);
|
|
|
Console.WriteLine("done writer #3: {0} ms", Environment.TickCount - t1);
|
|
|
},
|
|
|
() => {
|
|
|
var buffer = new int[rBatch];
|
|
|
|
|
|
while (read < total) {
|
|
|
int actual;
|
|
|
if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
|
|
|
for (int i = 0; i < actual; i++)
|
|
|
r1 += buffer[i];
|
|
|
Interlocked.Add(ref read, actual);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Console.WriteLine("done reader #1: {0} ms", Environment.TickCount - t1);
|
|
|
}/*,
|
|
|
() => {
|
|
|
var buffer = new int[rBatch];
|
|
|
|
|
|
while (read < total) {
|
|
|
int actual;
|
|
|
if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
|
|
|
for (int i = 0; i < actual; i++)
|
|
|
r2 += buffer[i];
|
|
|
Interlocked.Add(ref read, actual);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Console.WriteLine("done reader #2: {0} ms", Environment.TickCount - t1);
|
|
|
}*//*,
|
|
|
() => {
|
|
|
var buffer = new int[rBatch];
|
|
|
|
|
|
while (read < total) {
|
|
|
int actual;
|
|
|
if (TryDequeueRange(queue, buffer, 0, rBatch, out actual)) {
|
|
|
for (int i = 0; i < actual; i++)
|
|
|
r3 += buffer[i];
|
|
|
Interlocked.Add(ref read, actual);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
Console.WriteLine("done reader #3: {0} ms", Environment.TickCount - t1);
|
|
|
}*/
|
|
|
)
|
|
|
.PromiseAll()
|
|
|
.Join();
|
|
|
|
|
|
|
|
|
Console.WriteLine(
|
|
|
"done: {0} ms, summ#1: {1}, summ#2: {2}, total: {3}, count: {4}",
|
|
|
Environment.TickCount - t1,
|
|
|
r1,
|
|
|
r2,
|
|
|
r1 + r2 + r3,
|
|
|
total
|
|
|
);
|
|
|
|
|
|
Console.WriteLine("done");
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
