Loading ...
Sorry, an error occurred while loading the content.

Self & Parallelism

Expand Messages
  • Anne C. van Rossum
    Dear list members, Online I read some articles about Self. I find it a very interesting language. I m also interested in the optimizing compiler, but with a
    Message 1 of 2 , Jan 24, 2007
    • 0 Attachment
      Dear list members,

      Online I read some articles about Self. I find it a very interesting
      language. I'm also interested in the optimizing compiler, but with a
      slightly different touch.

      I'm thinking about a way in which an application can be sliced into
      different tasks. Within a task entities may communicate with each
      other in a synchronous way. Between tasks communication is in a
      asynchronous way. (A task is a threaded entity.) An optimizing
      compiler dynamically reconfigures the application in an amount of
      tasks that performs optimal. This depends e.g. on the amount of
      processors.

      I'm interested how parallelism, concurrency, distribution, etc. is
      seen in Self. What kind of abstractions are used or invented? Are
      threads adopted? Or are communicating sequential processes used? Or
      does Self have its own view on concurrency too?

      Kind regards,

      Anne
    • Jecel Assumpcao Jr
      Anne C. van Rossum wrote on Wed, 24 Jan 2007 10:29:07 -0000 ... Welcome to Self! Sorry that your email got stuck in moderation for two weeks - I had some
      Message 2 of 2 , Feb 8, 2007
      • 0 Attachment
        Anne C. van Rossum wrote on Wed, 24 Jan 2007 10:29:07 -0000
        > Online I read some articles about Self. I find it a very interesting
        > language. I'm also interested in the optimizing compiler, but with a
        > slightly different touch.

        Welcome to Self! Sorry that your email got stuck in moderation for two
        weeks - I had some problems with my spam filter eliminating Yahoo's
        notification message.

        > I'm thinking about a way in which an application can be sliced into
        > different tasks. Within a task entities may communicate with each
        > other in a synchronous way. Between tasks communication is in a
        > asynchronous way. (A task is a threaded entity.) An optimizing
        > compiler dynamically reconfigures the application in an amount of
        > tasks that performs optimal. This depends e.g. on the amount of
        > processors.

        After the 1980s interest in this topic declined significantly, but now
        it is more popular than ever.

        > I'm interested how parallelism, concurrency, distribution, etc. is
        > seen in Self. What kind of abstractions are used or invented? Are
        > threads adopted? Or are communicating sequential processes used? Or
        > does Self have its own view on concurrency too?

        Self has the same model as Smalltalk-80, which is threads with fixed
        priorities that synchronize using semaphores. Unlike most Smalltalk
        implementations where this is hidden inside the virtual machine, in Self
        the scheduler is just a regular program that you can change or replace.
        Reinaldo Silveira, for example, took advantage of this to implement a
        very different concurrency model for his PhD thesis.

        You might find the work I did with tinySelf 1 interesting, even though I
        implemented a whole new interpreter (in Self) instead of just changing
        the scheduler:
        http://www.lsi.usp.br/~jecel/tiny.html#rel1

        There is also this paper that I wrote (compressed postscript rather than
        PDF - sorry) where I speculate about the use of the adaptive compilation
        technologies to adjust the level of parallelism in the running
        application to the number of processors available:

        http://www.lsi.usp.br/~jecel/jabs1.html

        -- Jecel
      Your message has been successfully submitted and would be delivered to recipients shortly.