public Task <BenchmarkReply> Post(BenchmarkRequest data)
{
// ProcessRequest(RequestType.PlainText, data);
return(Task.FromResult(new BenchmarkReply {
Message = data.Name
}));
}
public override async Task runBenchmark(BenchmarkRequest request, IServerStreamWriter <BenchmarkReply> responseStream, ServerCallContext context)
{
GC.Collect();
Console.WriteLine(request);
try
{
if (request.ShutdownServer)
{
Program.ShutdownRequested = true;
}
else
{
if (request.Algorithm == Algorithm.ProSecCo)
{
await runBatchMiner(request, responseStream, context);
}
else if (request.Algorithm == Algorithm.PrefixSpan)
{
await runPrefixSpan(request, responseStream, context);
}
}
GC.Collect();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
private async Task <CallResult[]> PlainTextAsync(int requestCount, CancellationToken ct)
{
var data = new BenchmarkRequest
{
Name = _config.GetRequestPayload(),
};
var duration = _config.GetDuration();
if (duration != TimeSpan.Zero)
{
// timeout base
using var cts = new CancellationTokenSource(duration);
using var linkedCts = CancellationTokenSource.CreateLinkedTokenSource(cts.Token, ct);
var linkedCt = linkedCts.Token;
using var pool = new TaskWorkerPool <BenchmarkRequest, BenchmarkReply>(_config.ClientConcurrency, linkedCt);
pool.RunWorkers((id, data, ct) => GetClient(id).SayHelloAsync(data), data, ct);
await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());
return(pool.GetResult());
}
else
{
// request base
using var pool = new TaskWorkerPool <BenchmarkRequest, BenchmarkReply>(_config.ClientConcurrency, ct)
{
CompleteCondition = x => x.completed >= requestCount,
};
pool.RunWorkers((id, data, ct) => GetClient(id).SayHelloAsync(data), data, ct);
await Task.WhenAny(pool.WaitForCompleteAsync(), pool.WaitForTimeout());
return(pool.GetResult());
}
}
private void ProcessRequest(RequestType requestType, BenchmarkRequest body)
{
if (requestType == RequestType.PlainText)
{
var writer = GetWriter(Writer, sizeHint: 160 * 16); // 160*16 is for Plaintext, for Json 160 would be enough
PlainText(ref writer, Encoding.UTF8.GetBytes(body.Name).AsSpan());
}
}
public async Task <BenchmarkReply> SayHelloAsync(BenchmarkRequest data)
{
var request = new StringContent(JsonSerializer.Serialize(data), Encoding.UTF8, "application/json");
using var res = await _client.PostAsync(_endpointPlainText, request);
res.EnsureSuccessStatusCode();
var content = await res.Content.ReadAsStringAsync();
return(JsonSerializer.Deserialize <BenchmarkReply>(content));
}
private async Task runBatchMiner(BenchmarkRequest request, IServerStreamWriter <BenchmarkReply> responseStream, ServerCallContext context)
{
Console.WriteLine("run batch miner " + request.UseTopK);
await Task.Run(async() => {
BatchMiner miner = new BatchMiner();
var batchStopwatch = new Stopwatch();
batchStopwatch.Restart();
long totalTimeElapsed = 0;
//int numBlocks = (int)Math.Ceiling(request.DBSize/(double)request.SampleSize);
await miner.ProcessCSVFile(
request.File,
request.Support,
request.K,
request.UseTopK,
request.SampleSize,
request.DBSize,
request.ErrorTolerance,
async delegate(List <Sequence> frequentSequencePatterns, double error, int iteration)
{
batchStopwatch.Stop();
totalTimeElapsed += batchStopwatch.ElapsedMilliseconds;
var reply = new BenchmarkReply
{
NrProcessedRecords = miner.NumTransactionsProcessed,
ReplyType = ReplyType.Batch,
Iteration = iteration,
Error = error,
BatchRuntimeInMillis = batchStopwatch.ElapsedMilliseconds,
TotalRuntimeInMillis = totalTimeElapsed,
PrevBlockFileReadingTime = miner.PrevBlockFileReadingTime,
PrevBlockPreProcessingRuntime = miner.Algorithm.PrevBlockPreProcessingRuntime,
PrevBlockPrefixSpanRuntime = miner.Algorithm.PrevBlockPrefixSpanRuntime,
PrevBlockSubsequenceMatchingRuntime = miner.Algorithm.PrevBlockSubsequenceMatchingRuntime
};
var ser = JsonConvert.SerializeObject(frequentSequencePatterns, _jsonSettings);
reply.SequencesInJson = ser;
await responseStream.WriteAsync(reply);
batchStopwatch.Restart();
},
long.MaxValue
);
await responseStream.WriteAsync(new BenchmarkReply
{
ReplyType = ReplyType.Complete,
TotalRuntimeInMillis = totalTimeElapsed
});
});
}
private void RunBenchmark(String pcapFilePath, IActorRef subject)
{
var captureInfo = new CaptureInfo(new Uri(pcapFilePath));
var req = new BenchmarkRequest {
CaptureInfo = captureInfo, PcapLoader = this._services.GetService <IPcapLoader>()
};
var probe = this.CreateTestProbe();
subject.Tell(req, probe);
var result = probe.ExpectMsg <ProcessingResult>(TimeSpan.FromSeconds(60));
this._output.WriteLine($"Total time: {result.TotalTime}");
}
public void Test_DoMain()
{
var request = new BenchmarkRequest
{
Constituent1 = _reader.ReadResource("Test.Resource.Constituent1.txt").Array1,
Constituent2 = _reader.ReadResource("Test.Resource.ConstituentExtrapolate.txt").Array1,
IndexProxy = _reader.ReadResource("Test.Resource.ProxyExtrapolate.txt").Array1,
FXRate = _reader.ReadResource("Test.Resource.FxRate.txt").Array1,
Const1Weight = 0.6M,
Const2Weight = 0.4M,
AssetClassLeverageLongTermTargetLTV = 0.525M,
AssetClassLeverageLTVImpliedInProxies = 0.5M
};
var result = Helpers.DoMain(request).Result;
var sum1 = result.Bench1.Sum();
var sum2 = result.Bench2.Sum();
Assert.AreEqual(1827, result.Bench1.Length);
Assert.AreEqual(1827, result.Bench2.Length);
Assert.AreEqual(100M, result.Bench1[0]);
Assert.AreEqual(102.01260179936821023510537295M, result.Bench1[1]);
Assert.AreEqual(102.28569387136973135806175615M, result.Bench1[2]);
Assert.AreEqual(60.613395807105584389034344311M, result.Bench1[1825]);
Assert.AreEqual(58.083916956257370307665124339M, result.Bench1[1826]);
Assert.AreEqual(128700.71734227535247154670352M, sum1);
Assert.AreEqual(100M, result.Bench2[0]);
Assert.AreEqual(99.65084634755699301704409669M, result.Bench2[1]);
Assert.AreEqual(98.47090088900808479798186066M, result.Bench2[2]);
Assert.AreEqual(87.17968565685839338007814813M, result.Bench2[1825]);
Assert.AreEqual(82.99126372590390566556216151M, result.Bench2[1826]);
Assert.AreEqual(155154.71822011685792957086427M, sum2);
}
public UnaryResult <BenchmarkReply> SayHelloAsync(BenchmarkRequest data)
{
return(UnaryResult(new BenchmarkReply {
Message = data.Name
}));
}
private async Task runPrefixSpan(BenchmarkRequest request, IServerStreamWriter <BenchmarkReply> responseStream, ServerCallContext context)
{
Console.WriteLine("run prefix span");
await Task.Run(async() => {
Stopwatch stopwatch = Stopwatch.StartNew(); //creates and start the instance of Stopwatch
List <Sequence> sequenceList = new List <Sequence>();
// open the CSV file
using (var reader = new StreamReader(File.OpenRead(request.File)))
{
while (!reader.EndOfStream)
{
// read the current line
string line = reader.ReadLine();
// split the line by comma (assuming CSV file)
string [] transactions = line.Split(new string[] { " -1 " }, StringSplitOptions.None);
List <Transaction> tr = new List <Transaction>(transactions.Length);
for (int i = 0; i < transactions.Length - 1; i++)
{
string [] items = transactions[i].Split(' ');
Transaction trans = new Transaction(items);
tr.Add(trans);
}
Sequence sequence = new Sequence(tr);
sequenceList.Add(sequence);
}
}
PrefixSpan algorithm = new PrefixSpan(sequenceList);
List <Sequence> frequentSequences = algorithm.MinSupportFrequentSequences(request.Support);
// stop the stopwatch after frequent patterns are
// returned
stopwatch.Stop();
var reply = new BenchmarkReply
{
NrProcessedRecords = request.DBSize,
ReplyType = ReplyType.Batch,
Iteration = 0,
Error = 0,
BatchRuntimeInMillis = stopwatch.ElapsedMilliseconds,
TotalRuntimeInMillis = stopwatch.ElapsedMilliseconds
};
var ser = JsonConvert.SerializeObject(frequentSequences, _jsonSettings);
reply.SequencesInJson = ser;
await responseStream.WriteAsync(reply);
reply = new BenchmarkReply
{
ReplyType = ReplyType.Complete,
TotalRuntimeInMillis = stopwatch.ElapsedMilliseconds
};
await responseStream.WriteAsync(reply);
});
}
public Task <BenchmarkReply> SayHelloAsync(BenchmarkRequest data)
{
return(Task.FromResult(new BenchmarkReply {
Message = data.Name
}));
}
public async static Task run()
{
var channel = new Channel("127.0.0.1:" + _port, ChannelCredentials.Insecure);
var client = new Benchmarker.BenchmarkerClient(channel);
Report report = new Report()
{
Id = _id,
Algorithm = _algorithm,
NumberOfRuns = _numberOfRuns,
SampleSize = _sampleSize,
ErrorTolerance = _errorTolerance,
Support = _support,
File = _file
};
Console.Write("computing or reading expected results...");
List <Sequence> expectedResults;
var cacheFilename = "../results/groundtruths/" + Path.GetFileNameWithoutExtension(_file) + "_" + _support + "_gt";
if (File.Exists(cacheFilename))
{
var ser = File.ReadAllText(cacheFilename);
expectedResults = JsonConvert.DeserializeObject <List <Sequence> >(ser, _jsonSettings);
}
else
{
Tuple <List <Sequence>, int> results = getGroundTruth(_file, _support);
expectedResults = results.Item1;
expectedResults.Sort((a, b) => b.Support.CompareTo(a.Support));
var ser = JsonConvert.SerializeObject(expectedResults, _jsonSettings);
File.WriteAllText(cacheFilename, ser);
}
Console.WriteLine(" done");
for (int r = 0; r < _numberOfRuns; r++)
{
Run run = new Run()
{
RunId = r
};
// shuffle
Console.Write("shuffle file for run " + r + "...");
var shuffledFile = shuffleDataset(_file);
Console.WriteLine(" done");
var ts = new CancellationTokenSource();
CancellationToken ct = ts.Token;
// setup memory monitor
Task.Run(async() =>
{
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
Console.WriteLine("Start Memory Monitor");
using (var call = client.monitorMemory(new MemoryRequest()))
{
while (await call.ResponseStream.MoveNext())
{
if (ct.IsCancellationRequested)
{
break;
}
var response = call.ResponseStream.Current;
double gb = response.MemoryUsgageInBytes / (double)1073741824;
Console.WriteLine("Current Memory Usage: " + gb.ToString("N2") + "GB" + " / " + (sw.ElapsedMilliseconds / 1000) + "s / run nr: " + r);
if (!run.MemoryUsagePerTimeInMillis.ContainsKey(sw.ElapsedMilliseconds))
{
run.MemoryUsagePerTimeInMillis.Add(sw.ElapsedMilliseconds, response.MemoryUsgageInBytes);
}
}
}
}
catch (Exception e)
{
Console.WriteLine("MEMORY MONITOR FAILED");
Console.WriteLine(e.Message);
Console.WriteLine(e.StackTrace);
Console.WriteLine(e.InnerException.StackTrace);
}
}, ct);
var request = new BenchmarkRequest
{
Id = _id,
Algorithm = _algorithm == "ProSecCo" ? Algorithm.ProSecCo : _algorithm == "PrefixSpan" ? Algorithm.PrefixSpan :Algorithm.Undefined,
SampleSize = _sampleSize,
K = _k,
UseTopK = _useTopK,
DBSize = _dbSize,
ErrorTolerance = _errorTolerance,
Support = _support,
File = shuffledFile,
ShutdownServer = false
};
Console.WriteLine(request);
using (var call = client.runBenchmark(request))
{
while (await call.ResponseStream.MoveNext())
{
var response = call.ResponseStream.Current;
if (response.ReplyType == ReplyType.Batch)
{
var sequences = JsonConvert.DeserializeObject <List <Sequence> >(response.SequencesInJson, _jsonSettings);
run.RuntimePerBatch.Add(response.BatchRuntimeInMillis);
run.Errors.Add(response.Error);
run.PrevBlockFileReadingTime.Add(response.PrevBlockFileReadingTime);
run.PrevBlockPreProcessingRuntime.Add(response.PrevBlockPreProcessingRuntime);
run.PrevBlockPrefixSpanRuntime.Add(response.PrevBlockPrefixSpanRuntime);
run.PrevBlockSubsequenceMatchingRuntime.Add(response.PrevBlockSubsequenceMatchingRuntime);
evaluate(run, response.Iteration, expectedResults, sequences, response.NrProcessedRecords);
/*Console.WriteLine("--- " + (run.Errors.Count() - 1));
* foreach (var seq in sequences)
* {
* var description = "";
* foreach(var itemSet in seq.Transactions) {
* if (itemSet.NumItems == 1)
* description += itemSet.ToString() + " ";
* else
* description +="{" + itemSet.ToString() + "} ";
* }
*
* description = description.Substring(0, description.Length - 1);
*
* Console.WriteLine(description + ", " + ((double)seq.Support / (double)response.NrProcessedRecords) * (double)_dbSize);
* }*/
}
else if (response.ReplyType == ReplyType.Complete)
{
run.Errors.Add(response.Error);
run.TotalRuntimeInMillis = response.TotalRuntimeInMillis;
}
}
}
ts.Cancel();
report.Runs.Add(run);
Console.WriteLine("Wait for a little...");
await Task.Delay(5000); // to make sure GC is done collecting on server side
}
if (_terminateServer)
{
client.runBenchmark(new BenchmarkRequest {
ShutdownServer = true
});
await channel.ShutdownAsync();
}
// write report
File.WriteAllText("../results/" + _id + ".json", JsonConvert.SerializeObject(report, new JsonSerializerSettings()
{
Formatting = Formatting.Indented
}));
}
