Atomic updates: Difference between revisions

 

=={{header|8th}}==

var bucket-size

 

 

=={{header|Ada}}==

with Ada.Numerics.Discrete_Random;

 

=={{header|AutoHotkey}}==

loop, %Buckets% {

Random, rnd, 0,50

{{works with|BBC BASIC for Windows}}

The BBC BASIC interpreter is single-threaded so the 'concurrent' tasks are implemented by timer events. In this context an 'atomic' update means one which takes place within a single BASIC statement, so it cannot be 'interrupted'. Two (or more) buckets can be updated atomically by making them RETURN parameters of a procedure.

DIM Buckets%(100)

 

{{libheader|pthread}}

#include <stdlib.h>

#include <stdbool.h>

===With OpenMP===

Compiled with <code>gcc -std=c99 -fopenmp</code>. The <code>#pragma omp critical</code> ensures the following block is entered by one thread at a time.

#include <stdlib.h>

#include <omp.h>

 

return 0;

595 800 2508 2750 470 1209 283 314 601 470 Sum: 10000

5 521 3339 1656 351 1038 1656 54 508 872 Sum: 10000

- The previous implementation tracked a "swapped" state - which seems a harder way to tackle the problem. You need to acquire the locks in the correct order, not swap i and j

 

using System; //Rand class

using System.Threading; //Thread, Mutex classes

 

{{works with|C++11}}

#include <array>

#include <chrono>

=={{header|Clojure}}==

Function returning a new map containing altered values:

(let [{f-bal from t-bal to} m

f-bal (- f-bal amt)

(assoc m from f-bal to t-bal))))</syntaxhighlight>

Since clojure data structures are immutable, atomic mutability occurs via a reference, in this case an atom:

(swap! *data* xfer :a :b 50) ;; atomically results in *data* holding {:a 50 :b 150}</syntaxhighlight>

Now for the test:

(let [{a-val a b-val b} m

diff (- a-val b-val)

=={{header|Common Lisp}}==

Depends on libraries in Quicklisp. STMX is a library that provides Software Transactional Memory.

 

(defpackage :atomic-updates

(bt:make-thread (lambda () (runner (lambda () (random 1.0))))))</syntaxhighlight>

{{out}}

#<SB-THREAD:THREAD "Anonymous thread" RUNNING {10058441D3}>

ATOMIC-UPDATES> (loop repeat 3 do (print-buckets) (sleep 1))

This implements a more scalable version than most of the other languages, by using a lock per bucket instead of a single lock for the whole array.

 

import std.conv: text;

import std.random: uniform, Xorshift;

This example uses a Java AWT window to display the current state of the buckets.

 

pragma.syntax("0.9")

 

[0,11,7,0,4,16,7,0,10,0] = 55

</pre>

-module( atomic_updates ).

-export( [buckets/1, buckets_get/2, buckets_get_all/1, buckets_move_contents/4, task/0] ).

 

=={{header|Euphoria}}==

if src < 1 or src > length(s) or dest < 1 or dest > length(s) or amount < 0 then

return -1

The Buckets class is thread safe and its private higher-order Lock function ensures that locks are taken out in order (to avoid deadlocks):

 

open System.Threading

 

This program performs a million concurrent transfers. Typical output is:

 

[|100; 100; 100; 100; 100; 100; 100; 100; 100; 100|] = 1000

[|119; 61; 138; 115; 157; 54; 82; 58; 157; 59|] = 1000

=={{header|FreeBASIC}}==

{{trans|Run Basic}}

Dim Shared As Uinteger cubo(1 To 10), a, i

For i As Uinteger = 1 To 10

 

=={{header|Go}}==

 

import (

=={{header|Groovy}}==

Solution:

 

def cells = []

So, at any given time, the current value map is either in the MVar or being examined or replaced by one thread, but not both. The IntMap held by the MVar is a pure immutable data structure (<code>adjust</code> returns a modified version), so there is no problem from that the ''display'' task puts the value back before it is done printing.

 

 

import Control.Concurrent (forkIO, threadDelay)

The following only works in Unicon:

 

 

procedure main(A)

=={{header|Java}}==

{{works with|Java|8+}}

import java.util.concurrent.ThreadLocalRandom;

 

 

=={{header|Julia}}==

 

function runall()

=={{header|Kotlin}}==

{{trans|Java}}

 

import java.util.concurrent.ThreadLocalRandom

=={{header|Lasso}}==

Lasso thread objects are thread-safe by design.

data

private buckets = staticarray_join(10, void),

=={{header|Logtalk}}==

The following example can be found in the Logtalk distribution and is used here with permission. Works when using SWI-Prolog, XSB, or YAP as the backend compiler.

:- object(buckets).

 

Sample output:

 

?- buckets::start.

Sum of all bucket values: 52

 

=={{header|Mathematica}} / {{header|Wolfram Language}}==

ReplacePart[

bucks, {src -> Max[bucks[[src]] - n, 0],

The program must be compiled with option <code>--threads:on</code>.

 

import math

import os

Uses a lock for every bucket. Enforces a locking order to avoid deadlocks.

 

%%

%% INIT

 

Sample output:

buckets(24 68 58 43 78 85 43 66 14 48 ,,,) sum: 5000

buckets(36 33 59 38 39 23 55 51 43 45 ,,,) sum: 5000

 

=={{header|Perl}}==

use 5.10.0;

 

 

=={{header|Phix}}==

<span style="color: #008080;">without</span> <span style="color: #008080;">js</span> <span style="color: #000080;font-style:italic;">-- (no threads or critical sections in JavaScript)</span>

<span style="color: #008080;">constant</span> <span style="color: #000000;">nBuckets</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">20</span>

child processes to handle the tasks, as this is the standard way

for general PicoLisp applications.

 

(de *Buckets . 15) # Number of buckets

 

=={{header|PureBasic}}==

#TotalAmount=200

Global Dim Buckets(#Buckets)

This code uses a ''threading.Lock'' to serialize access to the bucket set.

 

import threading

import random

 

=={{header|Racket}}==

 

(struct bucket (value [lock #:auto])

{{trans|Ruby}}

{{works with|Rakudo|2016.07}}

class BucketStore {

 

=={{header|Ring}}==

# Project : Atomic updates

 

 

=={{header|Ruby}}==

 

# A collection of buckets, filled with random non-negative integers.

 

=={{header|Run BASIC}}==

FOR i = 1 TO 10 : bucket(i) = int(RND(0)*100) : NEXT

 

=={{header|Rust}}==

{{libheader|rand}}

 

use std::sync::{Arc, Mutex};

 

=={{header|Scala}}==

object AtomicUpdates {

 

=={{header|Smalltalk}}==

{{works with|Smalltalk/X}}

"create and preset with random data"

buckets := (1 to:NUM_BUCKETS)

=={{header|Swift}}==

 

 

final class AtomicBuckets: CustomStringConvertible {

<br>

{{works with|Tcl|8.5}}

package require Tk

 

 

Fibers are cooperatively (rather than preemptively) scheduled and only one fiber can run at a time. Consequently, simultaneous operations are impossible and all operations are therefore atomic by their nature.

import "scheduler" for Scheduler

import "timer" for Timer

=={{header|zkl}}==

Threads and thread safe objects (locks, lists, ints, etc) are built in.

const N=10;

var [const]

fcn threadA(b){ while(1) { b.transferArb(); } }

fcn threadE(b){ while(1) { b.transferEq(); } }</syntaxhighlight>

do(10){ threadA.launch(b); } do(10){ threadE.launch(b); }

 

</pre>

Another solution, using a Pipe as a "holding tank". Pipes are thread safe queues. This code just moves the values to and from the pipe to synchronize changes. The use of this class is the same as above, just change b:=B() to b:=C();

const N=10;

var [const]

{{omit from|LaTeX}}

{{omit from|M4}}

{{omit from|Make}}

{{omit from|PlainTeX}}

{{omit from|TI-89 BASIC}} <!-- Does not have concurrency or background processes. -->