[squeak-dev] Running process after image save/stop/restart
Eliot Miranda
eliot.miranda at gmail.com
Tue Mar 5 21:59:24 UTC 2013
On Tue, Mar 5, 2013 at 1:21 PM, Bert Freudenberg <bert at freudenbergs.de>wrote:
>
> On 2013-03-05, at 21:32, Eliot Miranda <eliot.miranda at gmail.com> wrote:
>
>
>
> On Thu, Feb 28, 2013 at 2:30 PM, Bert Freudenberg <bert at freudenbergs.de>wrote:
>
>> On 2013-02-28, at 22:38, Louis LaBrunda <Lou at Keystone-Software.com>
>> wrote:
>>
>> > If a process is running when an image is saved, is the process stopped
>> at
>> > any point in particular?
>>
>> The active process is stopped in the snapshot primitive (a.k.a. "image
>> saving") and resumes after it on startup. All other processes are waiting
>> on some semaphore anyway.
>>
>
> Nope. No processes are stopped. Processes are simply unable to run while
> in the snapshot.
>
>
> Yes, I used sloppy language, "suspended" is loaded in this context. The
> active process does not go through a suspend/resume cycle, it's simply that
> time "stops" and later "continues", so to speak.
>
That's OK. I was correcting "All other processes are waiting on some
semaphore anyway.". That's definitely not the case. Forgive my pedantry.
>
> Excellent explanation, Eliot :)
>
Tuesday OCD ;)
>
> - Bert -
>
> The key to understanding this is understanding the scheduler (the
> Processor global, an instance of ProcessorSheduler). It maintains an
> activeProcess and a set of runnable processes, implemented as an Array of
> lists of processes at the same priority. A runnable process (one not sent
> suspend or not waiting on a semaphore) is either the activeProcess or on
> one of the lists. This state is saved to the snapshot. At any time the
> scheduler's activeProcess is the first highest priority process in the set
> of runnable processes. It will only be deposed as activeProcess when
> either another higher-priority process becomes runnable or it yields or
> suspends or waits on a semaphore. If it suspends or waits on a semaphore
> it is removed from the set of runnable processes. If it yields it gets
> sent to the back of its run-queue and the next process in that queue
> becomes the runnable process. If it is the only runnable process at its
> priority yield is a noop.
>
> On loading the image the VM activates the activeProcess; the activeProcess
> will typically be in a method that has called the snapshot primitive and
> the system will continue, with the snapshot primitive answering true. All
> the other processes in the run queues are runnable but, just as before the
> snapshot, can't be run because the activeProcess is still runnable. But as
> soon as the activeProcess suspends, waits or yields, one of these processes
> may run.
>
> Several processes are terminated (terminate is suspend + run unwinds) on
> resuming the image. This is done to inform the VM of additional state to
> make these processes run. For example, the Delay process needs to tell the
> VM what the next delay expiry is on start-up. The delay semaphore (the
> semaphore the VM signals when the current active delay expires) is saved in
> the image in the specialObjects array, so it persists across a snapshot,
> but the VM doesn't persist the current delay expiry time.
>
> So any long-running process which doesn't need to inform the VM of
> anything special at start-up will just keep truckin' along, and nothing
> need be done. A snapshot really is like a fermata, a pause. It is not
> some kind of shut-down.
>
> As a side-note what happens if one does
>
> [Semaphore new wait] fork.
> Processor activeProcess yield.
>
> ?
>
> This creates a new process and adds it to the Processor's run queue. Once
> the process has been sent fork the current process doesn't reference it
> since it has been popped from the current process's stack, and so the only
> reference to the new process is from one of the Processors' run queues, but
> it isn't running yet because the activeProcess (the one that sent fork) is
> running. Wen the activeProcess yields the new process gets to run. Once
> it has created the new semaphore it sends wait to it. At this point it is
> removed from the Processor's run-queue and added to the semaphore's queue.
> So now there is a circular reference between the process and the semaphore
> and these are the only references to the process and the semaphore, and so
> both get garbage collected.
>
>
>
>>
>> > If the saved image is started, is there any way the process can tell?
>>
>> Not the process itself. But you surely keep the process in a class
>> somewhere, and the class can arrange to get notified on startup by adding
>> itself to the startup list. See addToStartUpList:.
>>
>
> exactly. one could also e.g. poll OSProcess to get the process ID of the
> VM process and see if that changes, but that's a horrible hack, and once in
> a blue moon will fail (cuz process ids are not unique and get reused).
>
> > I'm running a process that keeps running for a look time. It loops with
>> a
>> > delay and in the loop gets the date and time. If the date and time were
>> > obtained just before the save, they would be old at the time of the
>> image
>> > restart and need to be refreshed.
>>
>>
>> Delays get adjusted after resuming from snapshot. So it should just work.
>>
>
> exactly. the snapshot will look just like a long time on the run-queue
> whole the process is preempted by higher-priroity processes,
>
>
>> - Bert -
>>
> --
> HTH,
> Eliot
>
>
>
>
>
>
--
best,
Eliot
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://lists.squeakfoundation.org/pipermail/squeak-dev/attachments/20130305/cd3d65b3/attachment.htm
More information about the Squeak-dev
mailing list
|