private async Task CopyToExistingEntity(int id, WorkerProfile newWorker)
{
Entities.WorkerProfile existingWorker = await GetExistingWorker(id);
existingWorker.Name = newWorker.Name;
CopyAddress(existingWorker.Address, newWorker.Address);
existingWorker.Skills = newWorker.Skills;
}
public async Task <WorkerAccount> AddUserInformation(string authorization, WorkerProfile profile)
{
var token = getTokenFromAuthorization(authorization);
var currentAccount = GetByToken(token);
currentAccount.WorkerProfile.Email = profile.Email;
currentAccount.WorkerProfile.Fullname = profile.Fullname;
await context.SaveChangesAsync();
return(currentAccount);
}
public async Task <IActionResult> UpdateWorker(int id, [FromBody] WorkerProfile worker)
{
worker.Id = id;
if (workerRepository.Get(id) == null)
{
return(NotFound());
}
var savedWorker = await workerRepository.Save(worker, GetCreator(), id);
return(CreatedAtRoute(nameof(GetWorkerById), new { id = savedWorker.Id }, savedWorker));
}
public Task <WorkerProfile> Save(WorkerProfile worker, string creator, int id = 0)
{
throw new System.NotImplementedException();
}
private bool HasAllSkills(WorkerProfile worker, IList <Skill> skills)
{
return(skills.All(s => ContainsSkill(worker.Skills, s)));
}
void WorkerThread(object obj)
{
Thread.Sleep(1000);
WorkerProfile workerProfile = (WorkerProfile)obj;
List <int> OpPercentages = workerProfile.OpRatio;
long IterationCount = workerProfile.TotalIteration;
int CurrentThreadId = workerProfile.WorkerId;
long OpCountPerIteration = workerProfile.OpCountPerIteration;
long UseAttempts = 0, DeleteAttempts = 0, AddAttempts = 0, UpdateAttempts = 0, LoadAttempts = 0;
int ms2Tick = (int)(5 * Stopwatch.Frequency / 1000);
OpPerformanceRecord useRec = new OpPerformanceRecord(workerProfile.WorkerId, "USE", ms2Tick);
OpPerformanceRecord deleteRec = new OpPerformanceRecord(workerProfile.WorkerId, "DELETE", ms2Tick);
OpPerformanceRecord updateRec = new OpPerformanceRecord(workerProfile.WorkerId, "UPDATE", ms2Tick);
OpPerformanceRecord addRec = new OpPerformanceRecord(workerProfile.WorkerId, "ADD", ms2Tick);
OpPerformanceRecord loadRec = new OpPerformanceRecord(workerProfile.WorkerId, "LOAD", ms2Tick);
//byte[] cellBuffer = new byte[CellSize * 3];
long[] _TimeoutOpCount = new long[OperationCategoryCount];
long[] _TimeOpSum = new long[OperationCategoryCount];
for (int i = 0; i < OperationCategoryCount; i++)
{
_TimeoutOpCount[i] = 0;
_TimeOpSum[i] = 0;
}
#region initialization
int opCount = 0;
for (int i = 0; i < OpPercentages.Count; i++)
{
opCount += OpPercentages[i];
}
CellOperationType[] OpArray = new CellOperationType[opCount];
opCount = 0;
for (int i = 0; i < OpPercentages.Count; i++)
{
for (int j = 0; j < OpPercentages[i]; j++)
{
OpArray[opCount] = (CellOperationType)i;
opCount++;
}
}
#endregion
long garbage = 0;
for (int currentIteration = 0; currentIteration < IterationCount; currentIteration++)
{
Stopwatch _sw_ = new Stopwatch();
int cellCountOfCurrentThread = ThreadCellIds[CurrentThreadId].Count;
Random tRandom = Randoms[CurrentThreadId];
for (long opI = 0; opI < OpCountPerIteration; opI++)
{
CellOperationType CurrentOpType = OpArray[tRandom.Next(opCount)];
int startI = tRandom.Next(cellCountOfCurrentThread);
int finalI = startI + tRandom.Next(10); //! try a random number of attempts
for (int i = startI; i < finalI; i++)
{
long cellId = ThreadCellIds[CurrentThreadId][(int)(i % cellCountOfCurrentThread)];
if (CurrentOpType == CellOperationType.USE)
{
UseAttempts++;
#region USE
_sw_.Restart();
int size, entryIndex;
byte * cellPtr;
ushort cellType;
TrinityErrorCode eResult = Global.LocalStorage.GetLockedCellInfo(cellId, out size, out cellType, out cellPtr, out entryIndex);
if (eResult == TrinityErrorCode.E_SUCCESS)
{
var junk = new byte[100];
if (size > 0)
{
int offset = Randoms[CurrentThreadId].Next(0, size);
int delta = Randoms[CurrentThreadId].Next(0, size);
if (Randoms[CurrentThreadId].NextDouble() < 0.8)
{
int remaining_bytes = (size - offset);
if (remaining_bytes > 0)
{
delta = -Randoms[CurrentThreadId].Next(0, remaining_bytes);
}
}
else if (size + delta > CellSize * 2)
{
delta = CellSize * 2 - size;
if (delta < 0 && offset - delta > size)
{
delta = size - offset;
}
}
if (delta != 0)
{
try{
cellPtr = Global.LocalStorage.ResizeCell(cellId, entryIndex, offset, delta);
}catch {
Console.WriteLine($"{size}:{delta}");
WorkerResizeException[CurrentThreadId] = true;
}
}
size = size + delta;
for (int c = 0; c < size; c++)
{
cellPtr[c] = (byte)(cellId + c);
}
}
Global.LocalStorage.ReleaseCellLock(cellId, entryIndex);
}
_sw_.Stop();
useRec.Record(_sw_);
#endregion
continue;
}
if (CurrentOpType == CellOperationType.DELETE)
{
DeleteAttempts++;
#region DELETE
_sw_.Restart();
if (Global.LocalStorage.RemoveCell(cellId) == TrinityErrorCode.E_SUCCESS)
{
Interlocked.Decrement(ref DeltaCellCount[CurrentThreadId]);
}
_sw_.Stop();
/*
* if (_sw_.ElapsedMilliseconds > 10)
* {
* _TimeoutOpCount[(int)CellOperationType.DELETE]++;
* Log("Warning : A Remove elapsed : " + _sw_.ElapsedMilliseconds + " millis.");
* }*/
deleteRec.Record(_sw_);
#endregion
continue;
}
if (CurrentOpType == CellOperationType.UPDATE)
{
UpdateAttempts++;
#region UPDATE
_sw_.Restart();
double prob_value = Randoms[CurrentThreadId].NextDouble();
int cell_size = 0;
if (prob_value < 0.0003)
{
cell_size = Randoms[CurrentThreadId].Next(2, MaxLargeObjectSize);
}
else
{
cell_size = Randoms[CurrentThreadId].Next(0, CellSize * 2);
}
Global.LocalStorage.UpdateCell(cellId, GetCellContent(cellId, cell_size));
_sw_.Stop();
updateRec.Record(_sw_);
#endregion
continue;
}
if (CurrentOpType == CellOperationType.ADD)
{
AddAttempts++;
#region ADD
_sw_.Restart();
if (Global.LocalStorage.AddCell(cellId, GetCellContent(cellId, CellSize), 0, CellSize, ushort.MaxValue) == TrinityErrorCode.E_SUCCESS)
{
Interlocked.Increment(ref DeltaCellCount[CurrentThreadId]);
}
_sw_.Stop();
addRec.Record(_sw_);
#endregion
continue;
}
if (CurrentOpType == CellOperationType.Load)
{
LoadAttempts++;
#region Load
_sw_.Restart();
byte[] cellBuff;
Global.LocalStorage.LoadCell(cellId, out cellBuff);
garbage += cellBuff.Length;
_sw_.Stop();
loadRec.Record(_sw_);
#endregion
continue;
}
}
}
}
Log("====WorkId : {0} all operations complete==== \n" +
"WorkId : {0} add attempts : {1}\n" +
"WorkId : {0} delete attempts : {2}\n" +
"WorkId : {0} update attempts : {3}\n" +
"WorkId : {0} cell count delta : {4}\n" +
"WorkId : {0} garbage : {5}\n"
,
CurrentThreadId, AddAttempts, DeleteAttempts, UpdateAttempts, DeltaCellCount[CurrentThreadId], garbage
);
lock (TimeoutOpCountLock)
{
for (int i = 0; i < OperationCategoryCount; i++)
{
TimeoutOpCount[i] += _TimeoutOpCount[i];
}
deleteRec.Output();
updateRec.Output();
addRec.Output();
}
}
public async Task <IActionResult> CreateWorker([FromBody] WorkerProfile worker)
{
var savedWorker = await workerRepository.Save(worker, GetCreator());
return(CreatedAtRoute(nameof(GetWorkerById), new { id = savedWorker.Id }, savedWorker));
}
private void AssertHasSkill(WorkerProfile worker, string skill)
{
worker.Skills
.Any(s => s.Name.Equals(skill, StringComparison.InvariantCultureIgnoreCase))
.Should().BeTrue();
}
