Wenn es in einem Terminal laufen soll, dass in einem X-Server läuft (also ein grafisches Terminal, ala xterm, gnome term, konsole etc.), dann kannst du die Xlib dafür verwenden. Du musst ja kein Fenster öffnen. Aber das wird dir nichts bringen, wenn du auf einem reinen Terminal (also einer virtual console, ohne laufenden X-Server) das Programm laufen lassen willst. Dafür kannst du GPM nutzen.
D3lta schrieb:
auf Linux ist es ja möglich dies über die Escape-Sequenzen zu erreichen.
Das Problem dabei ist, dass eben jene Escape-Sequenzen von Terminal zu Terminal unterschiedlich sind. Deshalb ist die Verwendung einer Bibliothek wie ncurses sehr empfehlenswert, damit man sich nicht selbst mit den Feinheiten der verschiedenen Terminals auseinander setzen muss.
Danke, der Link hilft sogar sehr. Es funktioniert jetzt.
IMHO -static und -shared widersprechen sich nicht unbedingt. In einem weiteren Schritt werden dann alle Libraries zusammenkopiert und in ein Archiv verpackt. Dank dem -static sollte das dann auf verschiedenen Platformen ohne Probleme laufen (nicht allen, aber das ist fuer diesen speziellen Fall egal). Und mit dem -shared kann ich die Library doch ueber JNI ansprechen.
Mit Firefox funktioniert es problemlos, einfach Login und Pw eingeben und fertig. Unter Windows habe ich Tortoise installiert, damit bin ich auch sehr zufrieden. Gibt es vielleicht ein ähnliches Programm für Linux? Ansonsten werd ich wohl mal die Funktion von Eclipse ausprobieren.
Füg einfache -Ipfad zu den CFLAGS hinzu.
Aber warum dein erster Versuch nicht geht: Bei Make werden die Zeilen in jeweils neuen Shellprozessen ausgeführt. Außerdem solltest du make nicht direkt aufrufen, sondern lieber $(MAKE) nehmen
.PHONY: config all
config:
CFLAGS=-Ipfad $(MAKE) all
all: foo # <- implizite Regel nutzen, dann werden die CFLAGS auch richtig berücksichtigt
Wobei ich autotools oder CMake empfehlen würde, anstelle die Makefile per Hand zu schreiben.
cooop schrieb:
Bei der obigen Realisierung hab ich das Problem dass diese Informationen weg sind. nach einem wait() waere der Kindprozess beendet, durch ein SIGCHLD abfangen ist es ein Zombieprozess. Wahrscheinlich liegt das Problem eher schon darin, dass der Prozess nach Ende dieses exec Aufrufs zum Zombie wird (automatisch, jeder danach kommende Befehl im Kindprozess wird nicht ausgefuehrt).
exec* überschreibt den aktuellen Prozess mit dem neuen Prozess. Daher kehrt der Aufruf von exec* auch nicht zurück, wenn es keinen Fehler beim überschreiben gibt.
Eigentlich dachte ich, dass man die Informationen noch auslesen kann, solange der Prozess ein Zombie ist. Aber zB man: wait4(2) hat ja eine rusage Struktur, wenn du den Ressourcenbedarf auslesen willst.
Hallo ape,
Das Einstellen der Thread Prio mit der pthread scheint leider nicht so einfach zu gehen.
Bitte prüfe unbedingt die return values der Funktionen.
Grundsätzlich ist es normal das ein Thread oder auch ein Prozess unterbrochen wird. Das muss die Programmierung berücksichtigen,
hier helfen auch keine Prioritäten, bzw.
Du hast dann immer noch keine Garantie.
Eine 'saubere' Implementierung kommt in der Regel ohne Thread Prioritäten aus,
bzw. regelt die Prioritäten über events, mutexe und job queues.
Theoretisch kann man natürlich einen Lock während des Empfangs setzen
und verhindern das die anderen Threads während des Empfangs weiter arbeiten können.
Wobei es spätestens hier schon komisch klingt und man sich gerne die Frage stellen kann: "Warum dann überhaupt threads verwenden?"
Nur meine persönliche Meinung.
Gruß Frank
hi,
ich habe ein Simulationsprogramm für Bildverarbeitung, wobei die Vorverarbeitung der Bilder durch einen eigenen Prozess erfolgt. Die Kommunikation zwischen diesem Prozess und meinem Programm geschieht über shared memory.
Das läuft nach folgendem Schema:
mein Programm:
/*starten des Vorverarbeitungsprozesses:*/
system("preproc parameter > /dev/null &");
/*shared memory ist jetzt angelegt*/
for (n=1; n<anzahl_bilder; n++)
{
/*starten der Verarbeitung:*/
Bild in shared memory laden
Flag "Bild OK" setzen
/*warten auf Vorverarbeitungsergebnis:*/
loopcnt = 0;
while (!data_available() && (loopcnt < 100) )
{
usleep(11000); /*hier gebe ich dem Prozess preproc Zeit zum Arbeiten*/
loopcnt++;
}
printf("preproc-Zeit: %d", loopcnt);
Vorverarbeitungsergebnisse abholen und weiterverarbeiten
}
Mit data_available() wird ein Flag im shared memory geprüft, welches durch preproc gesetzt wird, sobald die Vorverarbeitung fertig ist.
Das funktioniert, wenn ich das Programm einfach laufen lasse. Die normale Rechenzeit des Prozesses preproc, gemessen mit loopcnt, beträgt 20 Durchläufe der Warteschleife.
Wenn ich jedoch mit dem Debugger arbeite - Breakpoint auf der Zeile "Vorverarbeitungsergebnisse abholen" -, läuft jedesmal loopcnt auf 100 hoch, und preproc hat kein Ergebnis geliefert.
Der Debugger, gdb, scheint den Prozess preproc zu blockieren.
Das Programm preproc existiert nur als Binärmodul und kann daher nicht verändert bzw. debugged werden (historisch bedingt).
Ich stehe momentan völlig auf dem Schlauch. Hat jemand eine hilfreiche Idee?
Alle Tipps sind sehr willkommen.
hallo,
ich verwende fcloseall() am Ende meines Programms, welches mehrere Dateien öffnet und sie sukzessive füllt.
Das hat bisher immer funktioniert. Nach diversen Umstellungen in meinem Programm hängt sich jedoch diese function auf.
Woran kann das liegen?
Hat sich erledigt - habe endlich den Fehler gefunden - ich sollte s_addr und nicht in_addr (ein mal long int, ein mal struct) vergleichen.
also falls jemand mal diesen Thread auf der Suche nach einer Lösung aufruft - ip adressen können so verglichen werden:
if ( cli_addr.sin_addr.s_addr == inet_addr(r_ip.c_str()) ) {...}
Danke an alle
hallo
ich versuche gerade zwei IP adressen zu vergleichen - die eine bekomme ich von der accept Funktion ausgefüllt
/*
* l_fd - local file descriptor
* cli_addr - struct sockaddr_in
*/
socklen_t clilen = sizeof(cli_addr);
accept(l_fd, (sockaddr*) &cli_addr, &clilen))
die andere Adresse is eine als String gegebene IP Adresse
std::string ip = "1.1.1.1";
jetzt will ich diese vergleichen
if ( cli_addr.sin_addr.in_addr == inet_addr(ip.c_str()))
// oder auch
if ( ntohl (cli_addr.sin_addr.in_addr) == ntohl( inet_addr(ip.c_str()))
ich bekomme beide Male folgende Fehlermeldung:
error: invalid use of ‘in_addr::in_addr’
Woran liegt es?
danke
Hallo Inge:
Da muss sich doch schon längst mal wer hingesetzt haben und "malloc2" oder Ähnliches implementiert haben.
Es gibt sicherlich einige libs, die Serialisierung unterstützen,
vielleicht auch welche wo man einen allocator mit angeben kann
oder sogar einen shared memory allocator aussuchen kann.
Oft wird jedoch klassisch kopiert.
Geh doch mal suchen und prüfe ob es deinen Anforderungen genügt.
Ich würde es selber schreiben, wenn die Notwendigkeit da wäre.
Hinweis:
Die Notwendigkeit war in mehr als 10 Jahren nicht gegeben,
weil die Vorverarbeitung und Nacharbeitung meistens deutlich mehr Performance schluckt.
Es ist unter Umständen maximale Performance möglich,
so etwas zu nutzen kann ein Wettbewerbsvorteil sein ...
Ob entsprechende libs frei verfügbar sind?
Ein Ansatz über eine Pipe ist oft ähnlich schnell,
und verbraucht weniger Speicher wenn streamed verarbeitet werden kann.
Die Pipe benutzt ja intern shared memory.
Im Grunde ist streamed Verarbeitung sowieso die hohe Kunst,
leider sind die Software Designs zu selten geeignet für solche streamed Ansätze.
Gruß Frank
Ein Signal wie SIGHUP an den laufenden Daemon senden ist eine ziemlich übliche Lösung, soweit ich weiß. Die passende Prozess-ID steht normalerweise in /var/run/process_name.pid oder einer ähnlichen Datei (die dein Programm natürlich anlegen muss).
Hallo zusammen,
soweit ich die Valgrind-Doku verstehe, kann ich eine Stacktrace angeben, welcher ausgeblendet werden soll, in den Analyseergebnissen. Wenn ich nun aber viele Ergebnisse aus Bibliotheken und nur wenig aus meinen Programm habe, ist dies sehr aufwendig. Ich würde gern eine Regel definieren, welche mir nur Stacktraces einblendet, welche einen bestimmten Namespace enthalten (z.B. A::B) ist dies möglich?
Danke.
Hallo. Hier die Situation.
Ich habe einen schreib-Prozess, der Text aus einer Textdatei liest und in eine named Pipe speichert.
Dann habe ich einen Leseprozess, der den Text aus der Named Pipe lesen soll.
Leseprozess
int main (int argc, char *argv[])
{
// File descriptor
FILE *r_pipe;
// Pipe öffnen
if ((r_pipe = fopen (argv[1], "r+")) == (FILE *)NULL)
{
printf ("ERR (Lesen): Fehler beim Öffnen der Pipe\n");
exit (1);
}
printf("Pipe geöffnet\n");
int ch, i = 0;
while((ch = fgetc(r_pipe)) != EOF)
{
putchar(ch);
i++;
}
fclose (r_pipe);
printf("Pipe geschlossen\nEs wurden %d Zeichen gelesen", i);
return(0);
}
Der Leseprozess bleibt immer in der Zeile while((ch = fgetc(r_pipe))!=EOF) hängen.
Hier ist der Schreibprozess:
int main (int argc, char *argv[])
{
// Zeiger auf Datei
FILE *fp;
// Datei text.txt mit Lesezugriff öffnen
if((fp = fopen(argv[2], "r")) == (FILE *)NULL)
{
printf("ERR (Schreiben): Fehler beim Öffnen der Datei.\n");
exit(1);
}
printf("Datei geöffnet\n");
// Zeiger auf NAMED PIPE
FILE *w_pipe;
// PIPE pipeline mit Schreibzugriff öffnen
if ((w_pipe = fopen(argv[1], "w+")) == (FILE *)NULL)
{
printf ("ERR (Schreiben): Fehler beim Öffnen der Pipe.\n");
exit (1);
}
// Pufferung abschalten
setvbuf(w_pipe, NULL, _IONBF, 0);
printf("Pipe geöffnet\n");
int ch, i = 0;
while((ch = fgetc(fp))!=EOF)
{
fputc(ch, w_pipe);
i++;
}
// PIPE schließen
fclose (w_pipe);
printf("Pipe geschlossen\nEs wurden %d Zeichen geschrieben.\n", i);
// Datei schließen
fclose(fp);
printf("Datei geschlossen\n");
return(0);
}
Hat hjemand eine Idee, wo mein Fehler liegt?
Vielen Dank