Для обеспечения адекватной загрузки аппаратных ресурсов, при увеличении кол-ва ядер в N раз, эффективность программы должна падать как минимум в N раз.

Эффективность программ падает в 2 раза каждые 18 месяцев.

Обычные изменяемые типы тоже будут но мигрировать между потоками они смогут только внутри объекта uniqueness типа.
В интерфейсе uniqueness типа могут использоватся только pure и uniqueness типы.

PERFORM LOCKED OPERATION (PLO)
The PERFORM LOCKED OPERATION instruction
can be used in a multiprogramming or multiprocessing
environment to perform compare, load,
compare-and-swap, and store operations on two
or more discontiguous locations that can be words
or doublewords. The operations are performed as
an atomic set of operations under the control of a
lock that is held only for the duration of the execution
of a single PERFORM LOCKED OPERATION
instruction, as opposed to across the execution
of multiple instructions. Since lock contention
is resolved by the CPU and is very brief,
the program need not include a method for
dealing with the case when the lock to be used is
held by a program being executed by another
CPU. Also, there need be no concern that the
program may be interrupted while it holds a lock,
since PERFORM LOCKED OPERATION will complete
its operation and release its lock before an
interruption can occur.

LA RT,H Initialize addresses in PL (T = temp)
ST RT,PL+76 Op4 address (address of H)
LA RT,C
ST RT,PL+108 p6 address (address of C)
LA RN,N Address of N 
ST RN,PL+60 Initialize op3 in PL (address of N)
LA R1,S PLT address = address of S
------------------------------------------------
SR RS,RS Dummy S. CC1 will probably be set
SR R,R Function code  (compare andload)
PLO RS,S,RS,S Obtain S while holding lock
------------------------------------------------
LA R,16 Function code 16 (csdst)
LOOP L RT,H Consistent H
ST RT,OFSTF(,RN) OFSTF = offset of F inN
L RT,C Consistent C
LA RT,1(,RT) C+1
ST RT,PL+92 Initialize op5 in PL (C+1)
LA RSP,1(,RS) RS/RSP = even/odd pair.
S+1 in RSP
PLO RS,S,,PL
BNZ LOOP Br if S changed (if CC not 0)

try_trx:
  chkpt on_failure ; начинаем транзакцию
                   ; как параметр передаём адрес, куда перейти в случае провала транзакции
  ; выполняем "произвольные" нужные действия
  commit ; пытаемся закоммитить
  ; если попали сюда, значит успешно
  ; в случае ошибки попадём на on_failure
  jmp on_success

on_failure:
  ; можно считать регистр cps (checkpoint status), что бы понять почему провалились
  ; можно выполнить back-off и т.д.
  jmp try_trx

on_success:
  ; транзакция выполнена успешно и атомарно

lock 3, r1, r1
ld r1 -> r2
add r2, 1
st r2 -> r1

lock 4, r1, r1
ld r1 -> r2
cmp r2, r3
jne end
st r4 -> r1
end:

lock 4, r1, r2
ld r1 -> r3
ld r2 -> r4
st r4 -> r1
st r3 -> r2

На ней можно сделать вобще все. Ибо все данные мъютекса, семафора и тп укатываются в одну линейку кеша.

Все обращения к защищенному объекту происходят в глобальном порядке. Каждое обращение к объекту видит изменения сделанные предыдущим обращением. Обращения к объекты без защиты запрещены (или не допускаются синтаксисом — нужное подчеркнуть).

synchronized(obj)
{
  ... obj ...
}

uniqueness type UniquenessArray[Type]
where Type : pure
{
    public this(size : int)
    {
        arr = mutable array(size);
    }
    public Get(i : int) : Type
    {
        arr[i];
    }
    public Set(i : int, value : Type) : ()
    {
        arr[i] = value;
    }
    private arr : mutable array[Type];
}

WH>uniqueness type UniquenessArray[Type]
WH>where Type : pure
WH>{
WH>    public this(size : int)
WH>    {
WH>        arr = mutable array(size);
WH>    }
WH>    public Get(i : int) : Type
WH>    {
WH>        arr[i];
WH>    }
WH>    public Set(i : int, value : Type) : ()
WH>    {
WH>        arr[i] = value;
WH>    }
WH>    private arr : mutable array[Type];
WH>}
WH>

where Type : pure
{
    public this(size : int)
    {
        arr = uniqueness array(size);
    }
    public Get(i : int) : Type
    {
        arr[i];
    }
    public Set(i : int, value : Type) : ()
    {
        arr[i] = value;
    }
    private arr : uniqueness array[Type];
}

class synch_queue
{
  queue q;
  mutex guard;
  
  void enqueue(T v)
  {
    lock l (guard);
    q.enqueue(v);
  }

  T dequeue()
  {
    lock l (guard);
    return q.dequeue();
  }
};

void someFunction(global_ptr<MyObject> obj)
{
    local_ptr<MyObject> loc=obj; //Тут берём блокировку
    ... //Работаем
}

vector v = new mutable vector (100);
mutate(v);
declare_const(v);
read(v);
mutate(v); // - не скомпилируется

if (rand())
  declare_const(v);

{
  int x = 0; // можно
  switch (y)
  {
    case 0:
    {
      int w = 0; // можно
    }
    break;
    case 1:
      int q = 0; // нельзя
      break;
  }
}

def mtxN = array(100, 200, (i, j) => mtxNminus1[i, j] + 1);

hash_map const m = create_and_initialize_complex_hash_map();