create_thread_for_cpu(cpu_index, thread_func);
// Поехали!

apply_as_simd(array_pointer, array_size, applied_function);

AVC>matrix operator*(const matrix &a, const matrix &b) 
AVC>/* здесь можно добавить какое-нибудь ключевое слово вроде nosideeffect */
AVC>{
AVC>  matrix c;
AVC>  int i, j, k;
AVC>  for (i = 0; i < m; ++i)
AVC>    for (j = 0; j < n; ++j) {
AVC>      c[ i ][j]  = 0;
AVC>      for (k = 0; k < t; ++k)
AVC>        c[ i ][j] += a[ i ][k] * b[k][j];
AVC>    }
AVC>  return c;
AVC>}
AVC>

                       time     space  prog.size
1.0    Erlang HiPE #2  5.18     4,996    263    
1.1    Haskell GHC     5.86     2,696    236    
1.4    Forth GForth    7.00     1,052    305    
4.9    Smalltalk GST   25.32    8,676    435    
5.3    SML MLton #2    27.24    5,892    319    
5.6    Lua #2          29.00    1,664    229    
6.1    C++ g++         31.35    4,948    1086
...

LCR>>    % чего-то тут рендерим... 
Т>... а вот здесь самое интересное
LCR>>    ok.

func1({A1,A2,A3,A4,A5}) -> {A1,A2,A3+1,A4,A5}.

let rec inner_loop k v m1i m2 j =
  if k < 0 then v
  else inner_loop (k - 1) (v + m1i.(k) * m2.(k).(j)) m1i m2 j

let mmult rows cols m1 m2 m3 =
  let last_col = cols - 1
  and last_row = rows - 1 in
  for i = 0 to last_row do
    let m1i = m1.(i) and m3i = m3.(i) in
    for j = 0 to last_col do
      m3i.(j) <- inner_loop last_row 0 m1i m2 j (* modify here! *)
    done;
  done

mmult(M1, M2) -> 
    Inner = size(M2),
    NRows = size(M1), 
    mmult(Inner, NRows, NRows, [], M1, M2).

mmult(_, _, 0, MM, _, _) ->
    list_to_tuple(MM);
mmult(I, C, R, MM, M1, M2) ->
    NewRow = rowmult(I, C, R, [], M1, M2),
    mmult(I, C, R-1, [NewRow | MM], M1, M2).

rowmult(_, 0, _, L, _, _) ->
    list_to_tuple(L);
rowmult(I, C, R, L, M1, M2) -> 
    Sum = sumprod(I, C, R, 0, M1, M2),    % calculate c_{ij} = \sum_k a_{ik}b_{kj} 
    rowmult(I, C-1, R, [Sum | L], M1, M2).

sumprod(0, _, _, Sum, _, _) -> Sum;
sumprod(I, C, R, Sum, M1, M2) -> 
    Newsum = Sum + element(I, element(R,M1)) * element(C, element(I,M2)),
    sumprod(I-1, C, R, NewSum, M1, M2).

Armstrong and Virding have proposed a one-pass mark-and-sweep garbage collector [AV95]. The collector is designed for languages that prohibit destructive operations (i.e. values can not be overwritten), and is used in a Erlang implementation. Since destructive operations are not allowed, references can only refer to older objects. The collector marks the objects from the youngest to the oldest. If no other object has referred to an object that is being marked, it can be reclaimed immediately (since only younger objects can refer to it.) All objects are kept in a singly linked list to keep the objects in order. All GC operations have predictable runtime
behavior. Thus, it can be used for real-time systems if it is scheduled to guarantee memory availability.

AVC>Обычный поток не требует специальных средств синхронизации до тех пор, пока он не обращается к разделяемым ресурсам. Например, скромно вычисляет что-то в своем стеке с помощью реентерабельных функций без побочных эффектов.

class A { public X meth(); }

class B
{
  private X x;
  public void fun(A a)
    {
        this.x = a.meth(); // здесь лок нужно захватить, а?
    }
}

AVC>А эмуляция императивного стиля на ФЯ?

State1 = modify(State), % ниже переменная State не используется

LCR>class A { public X meth(); }

LCR>class B
LCR>{
LCR>  private X x;
LCR>  public void fun(A a)
LCR>    {
LCR>        this.x = a.meth(); // здесь лок нужно захватить, а?
LCR>    }
LCR>}
LCR>

public X Meth ()
{  
  System.Monitor.Enter(this);
  try
  {
    X x = ...
    return x;
  }
  finally
  {
    System.Monitor.PulseAll(this);
    System.Monitor.Exit(this);
  }
}

PROCEDURE Meth (): X;
  VAR x: X;
BEGIN {EXCLUSIVE}
  x := ...
  RETURN x
END Meth;

render_spawn(1) ->
    ok.
render_spawn(N) when is_integer(N) ->
    spawn(render_module, render, []),
    render_spawn(N - 1).

% в модуле render_module    
render() ->
    % чего-то тут рендерим...
    ok.

AVC>>Добавляю в библиотеку процедуру умножения матриц с использованием многопоточности. И пользуюсь ей.

matrix operator*(const matrix &a, const matrix &b) /* здесь можно добавить какое-нибудь ключевое слово вроде nosideeffect */
{
  matrix c;
  int i, j, k;
  for (i = 0; i < m; ++i)
    for (j = 0; j < n; ++j) {
      c[i][j]  = 0;
      for (k = 0; k < t; ++k)
        c[i][j] += a[i][k] * b[k][j];
    }
  return c;
}

Д>Тебе это ничего не напоминает?

LCR>                       time     space  prog.size
LCR>1.0    Erlang HiPE #2  5.18     4,996    263    
LCR>1.1    Haskell GHC     5.86     2,696    236    
LCR>1.4    Forth GForth    7.00     1,052    305    
LCR>4.9    Smalltalk GST   25.32    8,676    435    
LCR>5.3    SML MLton #2    27.24    5,892    319    
LCR>5.6    Lua #2          29.00    1,664    229    
LCR>6.1    C++ g++         31.35    4,948    1086
LCR>...
LCR>

35 C gcc 181.46 3,876 519

13 Ada 95 GNAT 69.64 6,960 452

LCR>Насколько велика область задач, где нужен массивный параллелизм? Скорее мала, чем велика. Это одна из "стратосфер человеческой мысли", и туда с обычными молотками и гвоздями не суются. Там нужны более тонкие инструменты

СГ>>  System.Monitor.Enter(this);

sychronized public void meth() {...}

public void meth()
{
    synchronized(this) {...}
}

    receive
        Msg -> true
    after Time ->  % вот здесь
        Pid ! Alarm
    end.

SynchronizedList list;

public void someMethod()
{
    Iterator iter=list.iterate();
    while(iter.hasNext())
    {
        //А что если тут коллекцию поменяют??
        Object obj=iter.next();
    }
}