cygwin minimo

Pacotes que tornam o cygwin minimamente útil para mim:

alternatives
ash
base-files
base-passwd
bash
binutils
bzip2
coreutils
crypt
cygutils
cygwin
cygwin-doc
editrights
findutils
gawk
gcc
gcc-mingw
gettext
grep
groff
gzip
less
libiconv
login
make
man
mingw-runtime
ncurses
netcat
pcre
popt
readline
rebase
run
screen
sed
tar
termcap
terminfo
texinfo
tzcode
vim
w32api
which

Monitorando tempo de execução de uma função

Esse macete eu achei especialmente útil na hora de estudar o desempenho dos diversos algoritmos de ordenação. Aprendi no "Advanced Programming in the UNIX Environment" (Stevens e Rago), no Seção 8.16.

Vamos direto à prática, para detalhes é necessário consultar o livro e/ou as man pages.

Primeiro temos que criar a seguinte função para imprimir o tempo:

#include <unistd.h>

static void imprimetempo(clock_t tempo) {
    static long clktck = 0;

    if(clktck == 0)
        if((clktck = sysconf(_SC_CLK_TCK)) < 0)
            perror("sysconf");

    printf("%7.2f s", tempo / (double) clktck);
}

E para que esta função seja útil temos que chamá-la de maneira análoga ao exemplo abaixo:

#include <sys/times.h>

int main() {
    clock_t ini, fim;
    .
    .
    .
    ini = times(NULL);
    funcao_que_quero_ver_quanto_tempo_leva(argumentos);
    fim = times(NULL);

    printf("Tempo que levou: ");
    imprimetempo(fim - ini);
    .
    .
    .
    return 0;
}

programacao em C para unix

Material clássico sobre programação em C para UNIX. Tem material sobre IPC, Threads e RPC. Aí está o link: http://www.cs.cf.ac.uk/Dave/C/

O que o #! faz

Essa eu li em http://br.geocities.com/cesarakg/tips-shell-programming.html.

Quando executamos um arquivo que começa com o #! (chamado de hash-bang) o kernel lê o arquivo, vê o hash-bang, e continua a ler o resto da linha. Então ele pega o que ele encontrar nesta linha depois do hash-bang e executa tendo como parâmetro o próprio arquivo.

Vamos aos exemplos:

O arquivo abaixo chama-se hello.sh:

#!/bin/bash
# hello.sh: o famigerado "Hello World!"
echo "Hello World!"

quando é digitado no shell:

prompt$ ./hello.sh

o kernel vai ver o #! e vai ler o que vem a seguir, neste caso '/bin/bash'. E então ele executa o equivalente a isto:

prompt$ /bin/bash hello.sh

Então lembrando: o kernel lê o que está depois do hash-bang e executa o que estiver lá, usando o nome do arquivo como parâmetro. No caso do exemplo acima temos o seguinte:

O que foi lido após o hash-bang: /bin/bash
Nome do arquivo: hello.sh


Um exemplo muito interessante mencionado no texto é o seguinte:

O nome do arquivo é helpme.

#!/bin/cat
vi unix editor
man manual pages
sh Bourne Shell
ksh Korn Shell
csh C Shell
bash Bourne Again Shell

O que é lido após o hash-bang: /bin/cat
Nome do arquivo: helpme

Portanto será executado: /bin/cat helpme

Uma observação interessante é que o bash (e a maioria dos shells) considera tudo que vem depois de um caractere '#' como comentário, portanto o hash-bang e toda a sua linha é um comentário para o shell. Porém no exemplo helpme acima, o /bin/cat não vai ignorar e #! e irá exibir o contúdo de todo o arquivo.

No documento mencionado existem outras dicas. O texto é curto e de rápida leitura. Eu recomendo.