Народ, сорри за долгое отсутствие.
Возникла проблема: кто-нибудь подскажет, сколько ресурсов (процессорного времени и памяти) тратится на fork () (ветвление процесса) в чистом виде, т. е. в процессе, состоящем только из этого системного вызова. Или по крайней мере, как это можно измерить - есть какие-нибудь функции для работы с таймером на уровне микросекунд, которыми можно получить время, прошедшее от определенного момента? usleep () не подходит...

Конкретизируй плиз. Что, где (так и напрашивается Когда)? А то что-то не очень догнал...

Короче, так. Есть в *NIX'ах (насчет других систем не знаю) такая функция - fork (), разветвляющий процесс на два, то есть после ее вызова создается копия текущего процесса. Родительскому процессу она возвращает pid порожденного процесса, а порожденному - 0. При этом все данные, открытые файловые дескрипторы, в общем, все копируется (в Linux это реализовано немного хитрее, а именно, данные копируются только когда один из процессов их изменяет, но это не суть). Так вот - возникает вопрос - а сколько, собственно времени уходит на то, чтобы этот процесс разветвить - много или не очень, и стоит ли его избегать, исходя из этого. Чтобы это измерить, нужны какие-то средства для работы с таймером. Можно, конечно, считывать значение счетчика тактов процессора (TSC) и считать в тактах, но там свои проблемы...

Короче, вопрос сводится к двум пунктам
1) Может ли кто-нибудь рассказать / дать ссылку на ресурс о fork () и о том, как она себя ведет?
2) Если нет, то хотя бы подскажите, как наиболее точно (желательно в микросекундах) измерить промежуток времени между двумя событиями?

А командой ps не получается? Там вроде всё достаточно подробно

А при чем тут ps? Если я не ошибаюсь, речь идет о выводе списка запущенных процессов?...

Нет. Мне нужно текущий процесс развести на два одинаковых, работающих параллельно. И fork () - это не команда shell, а системный вызов номер 2. Вопрос только один - сколько он жрет и как это измерить.

Накопал я про fork() кое-что. Так вот с помощью системного вызова fork() существующий процесс клонирует сам себя. К тому же он обладает уникальным свойством (!) - он возвращает сразу два значения. В порождённом процессе он возвращает 0, а в родительском - идентификатор потомка. После выполнения fork() новый процесс обычно запускает новую программу с помощью одного из системных вызовов exec*. Так вот к чему это я, если учесть какие действия выполняются данным процессом, то он не быстрый. К тому же прямо из С++ можно запустить два раза команду шелла (ps aux) в разных терминалах. До клонирования и после. Там далее смотришь на столбец TIME и видишь время запуска процесса. Второй вариант, до и после клонирования вернуть количество тиков с 1.1.1970 (день рождения UNIX) и сравнить их. Результат достаточно точен. К сожадению, я только начинаю учиться программировать на С++ в Линуксе и не знаю как это осуществить. Но можно кинуть вопрос по этому поводу в раздел по C++

P.S. Про процессы, fork(), ps и многое другое, я напишу следующую статью в "Основы администрирования UNIX"

P.S. P.S. NightGoblin Если это не то, или просто не помогло - извиняюсь

2simanyay
Хм, на самом деле про shell'ы я не додумался , но там будет результат не только fork'а, но еще и exec'а, который, кстати, занимает очень немало времени. А вот в тиках - можно поподробнее? Это не time() случайно?... если она - то не подойдет, там время, насколько я знаю, измеряется с точностью до секунды...

А на самом деле, я тут подумал - лучше, все-таки, наверное, будет считать в тактах процессора... И точнее уже вряд ли можно результат получить, да и на разных процессорах все равно пересчитывать придется.

В общем, в любом случае спасибо, все-таки немного чего-то всегда лучше чем совсем ничего!

Тики это и есть такты процессора

точно измерять определенный fork()
трудно: если ты измеряешь его, то это нужно либо на каждом вызове создавать какое-то софтовое прерывание, тем самым изменяя код fork()
короче типа того принцип неизвстности Айзенберга

но можно измерять большое кол-во форков измеряя какое время займет новому процессу
один дядя это уже делал, код лежит где-то там:
http://bulk.fefe.de/scalability/

по поводу строения fork()..
нужно скачать линуху ( в смысле кернель, напр. 2.6.14.4 )
и посмотреть код системного вызова clone()
в коде должны присутствовать вызовы типа copy-on-write некоторых регионов.

в общем нужно идти к источникам ( см. исходникам , т.к. на англ. и то и это source )



удачи.

bilbobagginz
Посмотрел я методику автора статьи. Ничего против такого подхода не имею, тем более что он перед собой ставил задачу не только замерить скорость форка сколько показать как это значение менятеся при разной нагрузке на скедьюлер. В случае NightGoblin не проще ли будет просто перед форком в родительском процессе вызвать gettimeofday, после чего вызвать его еще раз, но уже в процессе потомке. И собственно после этого потомок может вычислить разницу во времени. Ясное дело что между тем как копия процесса создана и между вызовом gettimeofday в процессе-потомке пройдет время, но общую картину такой метод даст.

PS Эти действия повторить столько раз сколько посчитаете нужным для более правдивого значения.

dwr_budr, вопрос не в том проще ли это сделать, а правильно ли это делать.
когда ты замерил gettimeofday(). у тебя в руках _реальное_время_, а оно вовсе не равно времени fork()-а. в принципе никогда.

если ты замеришь несколько раз это время, то узнаешь сколько реального времени проходит между вызовом и появлением процесса в системе. а это время в несколько раз дольше самого fork().

все же здесь нужно считывать время процессора, а это думаю надо делать таймером, или вообще вне процесса, на уровне ядра.

пока.