Jak uruchomić to samo polecenie linux w więcej niż jednej karcie / powłoce jednocześnie?

Czy jest jakieś narzędzie / polecenie w systemie Linux, którego można użyć do uruchomienia polecenia na więcej niż jednej karcie jednocześnie? Chcę uruchomić to samo polecenie: ./myprog argument1 argument2jednocześnie w więcej niż jednej powłoce, aby sprawdzić, czy muteksy działają poprawnie w programie wątkowym. Chcę być w stanie zwiększyć liczbę wystąpień tego programu, aby później obciążać mój kod.

Szukam czegoś w rodzaju tego, co robi ściana. Mogę myśleć o użyciu tty, ale wydaje mi się, że to bardzo bolesne, jeśli muszę skalować to do wielu innych powłok.

Jak już sugerował mavillan, użyj terminatora . Umożliwia wyświetlanie wielu terminali w sposób kafelkowy. Po włączeniu funkcji rozgłaszania możesz wprowadzić to samo polecenie jednocześnie na każdym terminalu.

Oto przykład z poleceniem date wysłanym do siatki 32 terminali.

tmux ma taką możliwość. (wraz z wieloma innymi przydatnymi możliwościami w tym samym stylu)

Można to zrobić za pomocą:

:setw synchronize-panes on

Multixterm

Kolejnym narzędziem do dodania do listy jest jedno o nazwie multixterm. Używa xtermterminali. Możesz go wywołać w następujący sposób:

$ multixterm

A kiedy się pojawi, zostanie wyświetlony interfejs GUI.

Następnie możesz rozpocząć rozkładanie xtermokien, klikając new xtermprzycisk. Tutaj na przykład wywołałem 2. Jeśli następnie klikniesz okno główne, możesz rozpocząć wpisywanie poleceń w obu oknach jednocześnie:

cast klawiatury

Wygląda na to, że jest dostępny tylko na Ubuntu, wygląda podobnie do multixterm.

fragment

Celem emisji klawiatury jest umożliwienie wysyłania naciśnięć klawiszy do wielu okien X jednocześnie. Pozwala to na przykład kontrolować liczbę terminali podłączonych do różnych, ale podobnych hostów do celów masowej administracji.

Możesz także wybrać nieterminale. Jeśli wymyślisz rozsądne wykorzystanie tej umiejętności, chciałbym usłyszeć o tym.

Program może wybrać okna do wysłania, dopasowując ich tytuły (używając podłańcucha) lub klikając je (w metodzie podobnej do funkcji zrzutu ekranu GIMP).

Program ma również możliwość odradzania wielu instancji terminala gnome wykonującego jedną komendę na wielu argumentach (na przykład wykonując polecenie „ssh” na kilku hostach). Terminale gnome są wywoływane z profilem „keycast”, jeśli istnieje (więc na przykład rozmiar czcionki może być mniejszy).

• Kontroluj wiele terminali jednocześnie
• cast klawiatury na starterze

Można to osiągnąć za pomocą iTerm2

Odniesienie: http://korishev.com/blog/2014/02/28/iterm2-broadcast-input/

Możesz zrobić coś takiego:

max_processes=20
for ((i=0; i<$max_processes; i++))
do 
    /path/to/myprog arg1 arg2 > /tmp/myprog.${i}.log &
done

Lub jeśli dane wyjściowe każdego polecenia są istotne podczas wykonywania, możesz ustawić ekran.

vi ~/.screenrc
screen -t inst1    1 /path/to/myprog arg1 arg2
screen -t inst2    2 /path/to/myprog arg1 arg2
screen -t inst3    3 /path/to/myprog arg1 arg2
screen -t inst4    4 /path/to/myprog arg1 arg2

Ekran wymaga więcej pracy ręcznej.

Jestem użytkownikiem KDE, z konsolą 2.13.2 w KDE 4.13.3 możesz to zrobić:

1. otwórz konsolę

2. podziel widok w pionie

3. pisz jednocześnie na każdym terminalu w oknie

Wypróbuj Terminator (terminal emulatora). Może mieć wiele sesji powłoki w tym samym oknie i możesz wysłać polecenie do wszystkich z nich.

Terminator

Możesz użyć narzędzia takiego jak MobaXterm, które pozwoli ci połączyć się jednocześnie, a następnie wkleić polecenia do wszystkich okien.

Jeśli chcesz zobaczyć tylko wynik 100. wykonania programu:

#!/bin/bash

prog="/path/to/myprog"
args="argument1 argument2"
max=100
for i in $(seq $max); do
    if [ $i -lt $max ]; then
        exec $prog $args &> /dev/null &
    else
        exec $prog $args
    fi
done

Można kontrolować konsolepoprzez DCOP. Przykładem jest tutaj :

#!/bin/bash

checkfile() {
  if [ ! -f $1 ]; then
    echo "could not find $1"
    exit 99
  else
    echo "OK"
  fi
}

# Check for App1 XML
echo -n "Checking for App 1 XML... "
XMLA=/domain/DM.xml
checkfile ${DEVROOT}/${XMLA}

# Check for App2 XML
echo -n "Checking for App 2 XML... "
hostname=$(hostname)
XMLB=/domain/DM_${hostname}.xml
checkfile ${DEVROOT}/${XMLB}

# Launch Konsole
echo -n "Launching konsole... "
K=$(dcopstart konsole-script)

[ -z "${K}" ] && exit 98
# Create second tab and resize
SDA=$(dcop $k konsole currentSession)
SDB=$(dcop $k konsole newSession)
dcop $K $SDA setSize 121x25

# Let bash login, etc.
sleep 1

# Rename the tabs
dcop $K $SDA renameSession "App 1"
dcop $K $SDB renameSession "App 2"

# Start services, letting user watch
echo -n "starting app1... "
dcop $K konsole activateSession $SDA
dcop $K $SDA sendSession "echo -ne '\033]0;DEV (${hostname})\007' && clear && starter $XMLA"
sleep 2
echo -n "starting app2... "
dcop $K konsole activateSession $SDB
dcop $K $SDB sendSession "echo -ne '\033]0;DEV (${hostname})\007' && clear && starter $XMLB"
echo done.

sh <<-STRESS & 
$( printf 'myprog &\n%.0b' \
    `seq 1 ${MAX_CONCURRENT_PROCS}` )
STRESS
echo "$!"

Zgadzam się z powyższym komentarzem @msw. Spowoduje to napisanie skryptu, który zostanie uruchomiony przez shproces działający w tle , i wydrukowanie shpid procesu potomnego , abyś mógł monitorować go i jego potomków podczas działania.

@Jinpeng był na dobrej drodze z GNU Parallel , tylko nie implementacją.

Przykład: Uruchom 10 równoległych instancji programu, z każdym wątkiem uruchamiającym program tylko raz:

parallel -j10 './myprog argument1 argument2 #' ::: {1..10}

Przykład: Uruchom 10 równoległych wątków, z których każdy z tych wątków będzie działał bez końca:

parallel -j10 'while true ; do ./myprog argument1 argument2 ; done #' ::: {1..10}

Możesz łatwo skalować to do setek wątków, zastępując 10w moich przykładach.

parallel -j200     ...     ::: {1..200}

Jeśli twój program generuje jakieś standardowe komunikaty i chcesz je widzieć tak, jak są tworzone (zamiast domyślnego, który je zestawia), --ungroupopcja równoległa może być użyteczna.

parallel --ungroup   ...

Jeśli uruchamiasz wiele wątków ze stacji roboczej i nie chcesz, aby wszystko przestało odpowiadać, rozważ nicerozważenie poddrzewa całego procesu w czasie uruchamiania.

nice -n19 parallel   ...

Dygresja, GNU równoległy nie jest zazwyczaj instalowany domyślnie, ale zazwyczaj w normalnych repo opakowania, więc po prostu zainstalować go jak każdy inny pakiet: dnf install parallel, apt-get install parallel, brew install parallel, itd.

Możesz rozpocząć procesy w tle za pomocą nohup.

Przykład:

nohup ./myprog -arg1 -arg2 &

Wydajność:

[1] 1769    
nohup: ignoring input and appending output to 'nohup.out'

Pamiętaj, aby zabić zadanie później za pomocą podanego PID:

kill 1769

Aby przenieść proces na pierwszy plan, musisz wprowadzić numer zadania, w tym przypadku [1]:

fg %1

GNU równoległe jest dokładnie tym narzędziem, którego szukasz. parallel -j 9 yourcommand

Mój mały do ​​frezowania:

#!/bin/sh

[ $# -lt 1 ] && {
        echo "Use: $0 <file>
        where file includes list of server"
        exit 9
}

cp ~/.config/terminator/config ~/.config/terminator/config.`date +%Y%m%d-%H%M`

cat ~/.config/terminator/config.`date +%Y%m%d-%H%M`|grep -v "^.plugins" >~/.config/terminator/config

inc=5
echo "  [[terms]]" >>~/.config/terminator/config
for i in `cat $1` ; do
        echo "   [[[window${inc}]]]"
        echo "       type = Window"
        echo "   [[[terminal${inc}]]]"
        echo "     profile = default"
        echo "     order = 0" 
        echo "     type = Terminal"
        echo "     parent = window${inc}"
        echo "     command = ssh $i"
        inc=$((inc+1))
done >>~/.config/terminator/config

echo "[plugins]" >>~/.config/terminator/config

Wykona konfigurację terminatora (warunki układu) dla wielu okien w jednej grupie.

EDYCJA: Przynajmniej terminator może wysyłać rozgłoszenie do każdego terminala w tej samej grupie. Tę funkcję można przełączać - możesz więc włączyć zapisywanie su - następnie wyłącz i zapisz własne hasło na terminalach i włącz je ponownie.