// thread cas data void thread_cas_data(object state) { var param = state as object[]; Assert.IsNotNull(param); var cache = param[0] as Cache <int, string>; Assert.IsNotNull(cache); int index = (int)param[1]; string data; int cas; for (int i = 0; i < cache_data_count; i++) { bool ret = cache.Get(cache_data_count * index + i, out data, out cas); Assert.IsTrue(ret); Assert.AreEqual(data, check_data.Substring(0, data_size_set[cache_data_count * index + i])); ret = cache.Set(cache_data_count * index + i, check_data.Substring(0, data_size_set[cache_data_count * index + i]), ref cas); Atomic.Inc(ref setCount); Assert.IsTrue(ret); } }
public static void AtomicAdd(this VariableView <Vector4> target, Vector4 operand) { Atomic.Add(ref target.SubView <float>(Vector4XOffset).Value, operand.X); Atomic.Add(ref target.SubView <float>(Vector4YOffset).Value, operand.Y); Atomic.Add(ref target.SubView <float>(Vector4ZOffset).Value, operand.Z); Atomic.Add(ref target.SubView <float>(Vector4WOffset).Value, operand.W); }
public ThreadFiber() { _actions = Atomic.Create(ImmutableList<Action>.EmptyList); _thread = CreateThread(); _thread.Start(); }
public void Release() { if (Group.IsFirstThread) { Atomic.Add(ref address.Value, 1); } }
protected ExprTableEvalStrategyUngroupedBase( ILockable @lock, Atomic <ObjectArrayBackedEventBean> aggregationState) { _lock = @lock; AggregationState = aggregationState; }
private void HandleConfig() { if (!File.Exists("config.json")) { ConfigData newConfig = new ConfigData() { Token = "YOUR_TOKEN_GOES_HERE" }; ChannelConfig chConf = new ChannelConfig(); newConfig.ChConfig = chConf; newConfig.LastHeight = (int)this.ActualHeight; newConfig.LastWidth = (int)this.ActualWidth; string json = JsonConvert.SerializeObject(newConfig, Formatting.Indented); byte[] fileContent = Encoding.UTF8.GetBytes(json); Atomic.WriteFile("config.json", new MemoryStream(fileContent)); config = JsonConvert.DeserializeObject <ConfigData>(File.ReadAllText("config.json")); } else { // this is also loaded on sync channel button, in case you ever change your token while program is still running i guess? // but please dont change token while program is still running wtf u doin config = JsonConvert.DeserializeObject <ConfigData>(File.ReadAllText("config.json")); this.Height = config.LastHeight; this.Width = config.LastWidth; } }
public void Atomic_Int_Store_Should_Fail() { var atomicInteger = new Atomic <int>(int.MaxValue); Assert.Throws <InvalidOperationException>(() => atomicInteger.Store(int.MinValue, MemoryOrder.Acquire)); Assert.Throws <NotSupportedException>(() => atomicInteger.Store(int.MinValue, MemoryOrder.Consume)); }
public void Atomic_Long_Load_Should_Fail() { var atomicLong = new Atomic <long>(long.MaxValue); Assert.Throws <InvalidOperationException>(() => atomicLong.Load(MemoryOrder.Release)); Assert.Throws <NotSupportedException>(() => atomicLong.Load(MemoryOrder.Consume)); }
public void Atomic_Int_Load_Should_Fail() { var atomicInteger = new Atomic <int>(int.MaxValue); Assert.Throws <InvalidOperationException>(() => atomicInteger.Load(MemoryOrder.Release)); Assert.Throws <NotSupportedException>(() => atomicInteger.Load(MemoryOrder.Consume)); }
public void Atomic_Int_Store_Should_Success(int initialValue, int storeValue, MemoryOrder order) { var atomicInteger = new Atomic <int>(initialValue, MemoryOrder.Relaxed); atomicInteger.Store(storeValue, order); Assert.Equal(storeValue, atomicInteger.Value); }
public void Atomic_Bool_Store_Should_Success(bool initialValue, bool storeValue, MemoryOrder order) { var atomicBoolean = new Atomic <bool>(initialValue, MemoryOrder.Relaxed); atomicBoolean.Store(storeValue, order); Assert.Equal(storeValue, atomicBoolean.Value); }
public void Atomic_Bool_Store_Should_Fail() { var atomicBoolean = new Atomic <bool>(true); Assert.Throws <InvalidOperationException>(() => atomicBoolean.Store(false, MemoryOrder.Acquire)); Assert.Throws <NotSupportedException>(() => atomicBoolean.Store(false, MemoryOrder.Consume)); }
public void Atomic_Bool_Load_Should_Fail() { var atomicBoolean = new Atomic <bool>(true); Assert.Throws <InvalidOperationException>(() => atomicBoolean.Load(MemoryOrder.Release)); Assert.Throws <NotSupportedException>(() => atomicBoolean.Load(MemoryOrder.Consume)); }
public void Atomic_Long_Store_Should_Fail() { var atomicLong = new Atomic <long>(long.MaxValue); Assert.Throws <InvalidOperationException>(() => atomicLong.Store(long.MinValue, MemoryOrder.Acquire)); Assert.Throws <NotSupportedException>(() => atomicLong.Store(long.MinValue, MemoryOrder.Consume)); }
public void Atomic_Long_Store_Should_Success(long initialValue, long storeValue, MemoryOrder order) { var atomicLong = new Atomic <long>(initialValue, MemoryOrder.Relaxed); atomicLong.Store(storeValue, order); Assert.Equal(storeValue, atomicLong.Value); }
public void Reset() { if (Group.IsFirstThread) { Atomic.Exchange(ref address.Value, 0); } }
void FixedUpdate() { foreach (Atomic atom in this.nearbyAtoms) { rb.AddForce(CoulombForce(atom)); } if (isBrokenJoint == true) { Debug.Log("JOINT BREAK!"); isBrokenJoint = false; Atomic otherAtom = FindDivorcedAtom(); if (otherAtom == null) { return; } BreakBondWith(otherAtom); } // just checking this.totalElectrons = TotalElectrons(); this.netCharge = NetCharge(); this.bondedAtomsCount = SharedElectrons(); this.nearbyAtomsCount = nearbyAtoms.Count; this.baseValenceElectrons = BaseValenceElectrons(); this.valenceElectrons = ValenceElectrons(); this.shareableElectrons = ShareableElectrons(); this.shareableHoles = ShareableHoles(); this.valenceOrbitalPositions = ValenceOrbitalPositions(); }
public void CloseApp(object sender, RoutedEventArgs e) { /* * MessageBoxImage mbi = new MessageBoxImage(); * string desc = "Are you sure you want to exit?\nAll the ongoing downloading will pause. (check for downloading, then warn?)"; * * // should be custom messagebox... because. * MessageBoxResult result = MessageBox.Show(desc, "Close app", MessageBoxButton.YesNo, mbi, MessageBoxResult.Yes); * * if (result == MessageBoxResult.No) * { * return; * } */ config.LastWidth = (int)this.ActualWidth; config.LastHeight = (int)this.ActualHeight; string json = JsonConvert.SerializeObject(config, Formatting.Indented); byte[] fileContent = Encoding.UTF8.GetBytes(json); Atomic.OverwriteFile("config.json", new MemoryStream(fileContent), "config.json.backup"); Application.Current.Shutdown(); }
private void PrepareForNewConfig() { _stack = new NaiveLockFreeStack(); _popped = new List <int>(); _poppedInOrder = new List <int>(); _pushingThreadFinished = new Atomic <bool>(); }
public TableInstanceUngroupedImpl( Table table, AgentInstanceContext agentInstanceContext) : base(table, agentInstanceContext) { eventReference = new Atomic<ObjectArrayBackedEventBean>(null); }
/// <inheritdoc /> public ValueTask <bool> MoveNextAsync() { var state = Atomic.Lock(ref _state); switch (state) { case _sInitial: _state = _sInitial; throw new InvalidOperationException("GetAsyncEnumerator was not called."); case _sEmitting: _tsAccepting.Reset(); _state = _sAccepting; _tsEmitting.SetResult(true); return(_tsAccepting.Task); case _sAccepting: _state = _sAccepting; throw new InvalidOperationException("MoveNextAsync is not reentrant."); case _sFinal: Current = default; _state = _sFinal; return(new(_atmbFinal.Task)); default: _state = state; throw new Exception(state + "???"); } }
private void TimerCallback(object _) { if (Atomic.CompareExchange(ref _state, _sInitial, _sWaiting) == _sWaiting) { _tsDelay.SetResult(); } }
private void SetFinal(Exception error) { Debug.Assert(error is not null); var state = Atomic.Lock(ref _state); switch (state) { case _sInitial: _tsDelay.Reset(); _state = _sFinal; _ctr.Dispose(); _tsDelay.SetException(error); break; case _sWaiting: _state = _sFinal; _ctr.Dispose(); _tsDelay.SetException(error); break; case _sFinal: _state = _sFinal; break; default: _state = state; throw new Exception(_state + "???"); } }
public void RemoveFolder(object sender, RoutedEventArgs e) { Button b = sender as Button; b.Opacity = 0.1; MessageBoxImage mbi = new MessageBoxImage(); string desc = $"Do you wish to {_deleteButtonText.Text}"; // should be custom messagebox... but meh MessageBoxResult result = MessageBox.Show(desc, "Remove from the list", MessageBoxButton.YesNo, mbi, MessageBoxResult.Yes); if (result == MessageBoxResult.Yes) { Tiles.Remove(b.CommandParameter.ToString()); Counters.Remove(b.CommandParameter.ToString()); chConfig.list.Remove(b.CommandParameter.ToString()); config.ChConfig = chConfig; UpdateFolderGrid(true); RefreshDropboxList(); myTray.UpdateTrayFolders(); string json = JsonConvert.SerializeObject(config, Formatting.Indented); byte[] fileContent = Encoding.UTF8.GetBytes(json); Atomic.OverwriteFile("config.json", new MemoryStream(fileContent), "config.json.backup"); } }
public void Atomic_Implicit_AcqRel_Should_Success() { Atomic <Guid> atomicGuid = SessionValue; Assert.NotNull(atomicGuid); Assert.Equal(SessionValue, atomicGuid.Value); }
private void PrepareForNewConfig() { interestedF = new Atomic <int>(); interestedS = new Atomic <int>(); victim = new Atomic <int>(); _threadsPassed = 0; }
/// <summary> /// Computes the pixel variances and their average /// </summary> public override void OnEndIteration(int curIteration) { // Update the mean and moment based on the buffered image of the current iteration Parallel.For(0, momentImage.Height, row => { for (int col = 0; col < momentImage.Width; ++col) { float val = bufferImage.GetPixel(col, row); momentImage.AtomicAdd(col, row, val * val / curIteration); meanImage.AtomicAdd(col, row, val / curIteration); } }); // Blur both buffers to get a more stable estimate. // TODO this could be done in-place by directly splatting in multiple pixels above BoxFilter filter = new(1); MonochromeImage blurredMean = new(meanImage.Width, meanImage.Height); MonochromeImage blurredMoment = new(meanImage.Width, meanImage.Height); filter.Apply(meanImage, blurredMean); filter.Apply(momentImage, blurredMoment); // Compute the final variance and update the main image Average = 0; Parallel.For(0, momentImage.Height, row => { for (int col = 0; col < momentImage.Width; ++col) { float mean = blurredMean.GetPixel(col, row); float variance = blurredMoment.GetPixel(col, row) - mean * mean; variance /= (mean * mean + 0.001f); Image.SetPixelChannel(col, row, 0, variance); Atomic.AddFloat(ref Average, variance); } }); Average /= momentImage.Height * momentImage.Width; }
private void PrepareForNewConfig() { A = new Atomic <int>(); B = new Atomic <int>(); _fastStoreDone = false; _serializeDone = false; }
private void SetFinal(Exception error) { var state = Atomic.Lock(ref _state); switch (state) { case _sInitial: _state = _sInitial; throw new InvalidOperationException(); case _sEmitting: _state = _sFinal; _ctr.Dispose(); _atmbFinal.SetExceptionOrResult(error, false); _tsEmitting.SetResult(false); break; case _sAccepting: Current = default; _state = _sFinal; _ctr.Dispose(); _atmbFinal.SetExceptionOrResult(error, false); _tsAccepting.SetExceptionOrResult(error, false); break; default: // _sFinal _state = state; break; } }
protected override void algorithm() { result = 0; Parallel.For(ExecuteOn, 0, sizeX, delegate(int x){ Atomic.Add(ref result, a[x]); }); }
private static void ThreadFunc(object state) { int index = (int)state; ThreadContext.Set((index + ThreadCount).ToString(), index); Atomic.Inc(ref lock_); while (Atomic.Cas(ref lock_, ThreadCount, ThreadCount) != ThreadCount) { Soyo.Base.Thread.Sleep(1); } bool result = ThreadContext.Contains("1"); Assert.IsFalse(result, "value should be false");; result = ThreadContext.Contains("2"); Assert.IsFalse(result, "value should be false");; for (int i = 0; i < ThreadCount; i++) { object value = ThreadContext.Get((i + ThreadCount).ToString()); if (i == index) { Assert.AreEqual(value, index, "value should be index"); } else { Assert.IsNull(value, "value should be null");; } Atomic.Inc(ref checkCount_); } }
public void ShouldTryAndUpdate() { var atomic = new Atomic<int>(100); const int expected = 110; bool success = atomic.TryUpdate(expected); Assert.True(success); Assert.AreEqual(expected, atomic.Value); }
public void ShouldTryAndUpdateUsingFunction() { var atomic = new Atomic<int>(0); const int expected = 100; bool success = atomic.TryUpdate(x => x + expected); Assert.True(success); Assert.AreEqual(expected, atomic.Value); }
public void Atomic_Long_Load_Should_Success() { var atomicLong = new Atomic<long>(long.MaxValue); Assert.Equal(long.MaxValue, atomicLong.Load(MemoryOrder.Relaxed)); Assert.Equal(long.MaxValue, atomicLong.Load(MemoryOrder.Acquire)); Assert.Equal(long.MaxValue, atomicLong.Load(MemoryOrder.AcqRel)); Assert.Equal(long.MaxValue, atomicLong.Load(MemoryOrder.SeqCst)); }
public void ShouldUpdateUsingFunction() { var atomic = new Atomic<int>(); const int expected = 100; int actual = atomic.Update(x => x + expected); Assert.AreEqual(expected, actual); Assert.AreEqual(expected, atomic.Value); }
public void ParameterlessConstructorShouldInitDefaultValue() { var atomicString = new Atomic<string>(); Assert.IsNull(atomicString.Value); var atomicInt = new Atomic<int>(); Assert.AreEqual(0, atomicInt.Value); }
public void Atomic_Int_Load_Should_Success() { var atomicInteger = new Atomic<int>(int.MaxValue); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Relaxed)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.Acquire)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.AcqRel)); Assert.Equal(int.MaxValue, atomicInteger.Load(MemoryOrder.SeqCst)); }
public void ConstructorShouldSetSpecifiedValue() { const string atomicStringValue = "this is atomic value"; var atomicString = new Atomic<string>(atomicStringValue); Assert.AreEqual(atomicStringValue, atomicString.Value); const int atomicIntValue = 100; var atomicInt = new Atomic<int>(atomicIntValue); Assert.AreEqual(atomicIntValue, atomicInt.Value); }
public void ShouldCallUpdateFunction() { bool called = false; var atomic = new Atomic<int>(100); atomic.Update(x => { called = true; return x; }); Assert.True(called); }
public void ConcurrentUpdateShouldFail() { var atomic = new Atomic<int>(); var result = false; atomic.Update(x => { var thread = new Thread(() => result = atomic.TryUpdate(100)); thread.Start(); return x; }); Assert.False(result); }
public EpisState(Atomic[] atomicsName, bool[] atomicsPositivity) { _expressionContext = new ExpressionContext(this); if (atomicsName.Count() == atomicsPositivity.Count()) { _status = new Dictionary<Atomic, bool>(); for (int i = 0; i < atomicsName.Count(); i++) { _status.Add(atomicsName[i] , atomicsPositivity[i]); } } }
public IEnumerable<Solution> Search(Atomic atomic, bool verify = true) { IEnumerable<Solution> enumerable; switch (_activeStrategy) { case Strategy.Bfs: enumerable = BreadthFirstSeach.Search(atomic, verify); break; case Strategy.Dfs: enumerable = DepthFirstSeach.Search(atomic, verify); break; default: enumerable = BreadthFirstSeach.Search(atomic, verify); break; } // return a fresh copy of the atomic foreach (var item in enumerable) { yield return new Solution(item.State.Copy()); } }
public FreshNameAtomic(Atomic atomic) : base(atomic) { }
public GenBexpAtomic(Atomic atomic) : base(atomic) { }
public IdAtomic(Atomic atomic) : base(atomic) { }
protected BlockAtomic(Atomic atomic) : base(atomic) { }
private Solution LazyScanMemberBody(MemberDecl md) { Contract.Requires(md != null); Console.WriteLine($"Starting thread: {System.Threading.Thread.CurrentThread.Name}"); Debug.WriteLine($"Scanning member {md.Name} body"); var function = md as Function; if (function != null) { var fun = function; if (fun.Body == null) return null; var expt = ExpressionTree.ExpressionToTree(fun.Body); expt.FindAndResolveTacticApplication(_tacnyProgram, fun); /* No reason ot generate new solution * if nothing has been changed */ if (!expt.Modified) return null; var res = expt.TreeToExpression(); var newFun = new Function(fun.tok, fun.Name, fun.HasStaticKeyword, fun.IsProtected, fun.IsGhost, fun.TypeArgs, fun.Formals, fun.ResultType, fun.Req, fun.Reads, fun.Ens, fun.Decreases, res, fun.Attributes, fun.SignatureEllipsis); var ac = new Atomic { IsFunction = true, DynamicContext = { newTarget = newFun } }; return new Solution(ac); } var m = md as Method; if (m?.Body == null) return null; List<IVariable> variables = new List<IVariable>(); List<IVariable> resolved; lock (_tacnyProgram) { resolved = _tacnyProgram.GetResolvedVariables(md); } variables.AddRange(m.Ins); variables.AddRange(m.Outs); resolved.AddRange(m.Ins); // add input arguments as resolved variables resolved.AddRange(m.Outs); // does not work for multiple tactic applications foreach (var st in m.Body.Body) { UpdateStmt us = null; WhileStmt ws = null; // register local variables if (st is VarDeclStmt) { VarDeclStmt vds = st as VarDeclStmt; variables.AddRange(vds.Locals); } else if (st is UpdateStmt) { us = st as UpdateStmt; } else if (st is WhileStmt) { ws = st as WhileStmt; us = ws.TacAps as UpdateStmt; foreach (var wst in ws.Body.Body) { if (!(wst is VarDeclStmt)) continue; var vds = wst as VarDeclStmt; variables.AddRange(vds.Locals); } } if (us == null || !_tacnyProgram.IsTacticCall(us)) continue; Debug.WriteLine("Tactic call found"); return ResolveTactic(variables, resolved, us, md, ws); } return null; }
public DeleteAtomic(Atomic atomic) : base(atomic) { }
public MergeAtomic(Atomic atomic) : base(atomic) { }
public OutboundMessagePipeline(IPipelineSink<ISendContext> output) { _output = Atomic.Create(output); }
public ExpressionAtomic(Atomic atomic) : base(atomic) { }
public FailAtomic(Atomic atomic) : base(atomic) { }
public PredicateAtomic(Atomic atomic) : base(atomic) { }
public void ShouldUpdateValue() { var atomic = new Atomic<int>(100); const int expected = 110; int actual = atomic.Update(expected); Assert.AreEqual(expected, actual); }
public ParamsAtomic(Atomic atomic) : base(atomic) { }
public ReturnAtomic(Atomic atomic) : base(atomic) { }
public VariantAtomic(Atomic atomic) : base(atomic) { }
public SolvedAtomic(Atomic atomic) : base(atomic) { }
public ChangedAtomic(Atomic atomic) : base(atomic) { }
public VariablesAtomic(Atomic atomic) : base(atomic) { }