DZone Snippets: Erlang code

Erlang Message Passing - Ruby point of view

teki321 (teki) — Wed, 15 Aug 2007 01:34:10 GMT



#!/usr/bin/env ruby



StartTime = Time.now

MT = Thread.current



$data = [0,0]



class ErProc

  def initialize(*args)

    #create thread

    @thr = Thread.new { func(*args) }

    @waiter = nil

    @data = nil

  end

  

  def func(*args)

    while true

      data = recieve()

      #p data

      data[1] = data[1] + 1

      if nil == args[0]

        $data = data

        MT.wakeup

      else

        args[0].send(data)

      end

    end

  end

  

  def recieve()

    # check waiting

    Thread.critical = true

    if @waiter

      @waiter.wakeup

      @waiter = nil

      Thread.critical = false

    else

      # thread stop

      Thread.stop

    end

    # returns data

    return @data

  end

  

  def send(data)

    # block till thread is running

    Thread.critical = true

    if !@thr.stop?

      @waiter = Thread.current

      Thread.stop

    end

    # strore data

    @data = data

    Thread.critical = false

    # starts thread

    @thr.wakeup

    # return

  end

end



raise "Parameters must be: thread_cnt message_cnt" if ARGV.size != 2



ProcCnt = ARGV[0].to_i

MsgCnt = ARGV[1].to_i



puts "Creating #{ProcCnt} processes"



prev = nil

1.upto(ProcCnt) do

  prev = ErProc.new(prev)

end



puts "Finish: #{Time.now - StartTime}"



puts "Sending #{MsgCnt} messages"



1.upto(MsgCnt) do |x|

  $data[0] = x

  prev.send($data)

  Thread.stop

  p $data

end



puts "Full time :#{Time.now - StartTime}"

a silly FIFO in Erlang (you should use OTP's queue.erl instead)

ayrnieu (Julian Fondren) — Sun, 01 Oct 2006 09:36:56 GMT



-module(fifo).

-export([new/0, loop/0, push/2, pop/1]).



new() ->

    spawn(?MODULE, loop, []).



loop() ->

    receive

        {Pid,pop} ->

            Pid ! {self(),receive {push,X} ->

                                  X

                          end),

            loop()

    end.



push(Fifo,X) ->

    Fifo ! {push,X},

    X.



pop(Fifo) ->

    Fifo ! {self(),pop},

    receive {Fifo,X} ->

            X

    end.

SET+

gregg.irwin (Gregg Irwin) — Mon, 29 May 2006 22:35:02 GMT



    set+: func [ ; Inspired by Erlang's list model.

        "Like SET, but words block is dialected."

        words  [any-block!] "Word after | gets remainder of series."

        series [series!]

        /local word= rule=

    ][

        word=: [set word word!]

        rule=: [

            any [

                '| word= (set word series) to end

                | word= (

                    set word pick series 1

                    series: next series

                )

            ]

        ]

        parse words rule=

    ]

    ;set+ [a | rest] [1 2 3 4 5]

    ;set+ [a b | rest] [1 2 3 4 5]

    ;set+ [a b c] [1 2]