Estou investigando algumas bloqueio esquema utilizando Semáforos. Para avaliar sistema básico de velocidade eu executar um loop de obter algumas informações semáforo e exibi-la:

enquanto:; fazer. / semshow; feito> res.txt

Corri presente em 3 caixas - duas semelhantes moderna HP Xeon caixas, executando um SCO OpenServer 5, o outro é o Fedora 2.6.9, e uma velha casa em modernas PIII Linux (não tenho info).
Os resultados são muito contra intuitiva:
H / W | SO | avg número de execuções ber sec
---- | --- | -------------------------
Xeon | SCO | 1700
Xeon | Fedora | 500
PIII | Linux (recente distro, desconhecido) | 900
Todos os três sistemas eram bastante ociosa no ensaio tempo.

Gostaria de perguntar, quais seriam os fatores que torna a antiga Unix para superar moderno SOs, também, como é PIII caixa superam moderna Xeon caixa em semelhante OS. Qualquer ponters seria apreciada.

Semshow O programa é muito básico, veja a lista abaixo:

 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include  <sys/timeb.h>
#include <time.h>
#include "semlib.h"
#define MODE_CREATE     0
#define MODE_REMOVE     1
key_t   IPCKEY;
main(int argc, char *argv[])
{
  int   sid, i;
  pid_t last_rpid, last_wpid;
  char  dbuf[80];
  union semun           arg;
  unsigned short        vals[NSEMS];
  struct timeb tb;
  struct tm *tp;
        if((IPCKEY = get_ipc_key()) == -1)
        {
                errexit("Can Not Obtain IPC Key");
        }
        if((sid = semget(IPCKEY, NSEMS, 0)) == -1)
        {
                errexit("Can Not Get Semaphore ID");
        }
        memset(vals, 0, sizeof(vals));
        arg.array = &vals[0];
        if(semctl(sid, NSEMS, GETALL, arg) == -1)
        {
                errexit("Can Not Get Semaphore Values");
        }
        if((last_rpid = semctl(sid, RDLOCK, GETPID)) == -1)
        {
                errexit("Can Not Get Semaphore R-Pid");
        }
        if((last_wpid = semctl(sid, WRLOCK, GETPID)) == -1)
        {
                errexit("Can Not Get Semaphore W-Pid");
        }
        ftime(&tb);
        tp = localtime(&tb.time);
        strftime(dbuf, sizeof(dbuf) - 1, "%T", tp);
        printf("%12li.%03i %s  RD:[%i]  WR:[%i] %i/%i\n",
                tb.time, tb.millitm, dbuf, 
                vals[RDLOCK], vals[WRLOCK],
                last_rpid, last_wpid);
        exit(0);
}

 
#define NSEMS   2
#define RDLOCK  0
#define WRLOCK  1
union   semun   {
        int             val;
        struct semid_ds *buf;
        unsigned short  *array;
};

Eis uma resposta: o seu tempo a medição é buggy. Veja homem sobre ftime () no Linux:

O Fedora tem caixa
/lib/tls/libc.so.6 -> libc-2.3.5.so
assim, eu assumo a versão é a 2.3.5.

Mas isso é além do ponto.

O número de vezes que o sistema puro executou o programa dentro de um segundo sistema geral que indicaria o poder, por assim dizer. Para meu espanto PIII no Linux conseguiu executar quase duas vezes mais do que um segundo ciclos withi Xeon 3.2GHz no Linux. Em seguida, o mesmo Xeon h / w sob antiga SCO OSR correr duas vezes mais rápido que PIII caixa.

Mas Problema # 1 é que você está medindo esse o caminho errado. Você tem muitas dependências na biblioteca solicita que sejam irrelevantes para o que você está tentando medir. Basta tirar todo o semáforo código, a re-teste, e veja o que você começa vezes. Ou, executar um loop 10000 x em torno do semáforo. Em seguida, para baixo à escala mais próxima segunda, para que não sejam microsegundo mistimings entrando em jogo.

Problema # 2 é que Semáforos exigir ônibus de acesso e são relativamente independentes da velocidade de processador.

Eu substituí o ftime com gettimeofday e re-executado, os resultados são os mesmos.

Resumindo novamente,
mesmo H / W:
programa sob SCO corre 3 vezes mais rápido do que em Linux,
mesmo SO:
programa é executado 2 vezes mais rápido do que no antigo PIII Xeon sobre moderno

Qualquer motivo? qualquer idéias?

Sinto muito, mas você ainda não tenha eliminado todos "solto variáveis". Mas o seu código no semáforo um loop de 1000 ou por aí e banco novamente.

Eu simplificado para o meu programa muito básico mínimo, ela recebe ipc chave, obtém id semáforos e lê valores de Semáforos e, em seguida, ele exibe em linha (tempo e semáforo valores). Isso é tudo que faz.

Então eu executá-lo no seguinte maneira:
$ Simultaneamente:; fazer tstshow; feito> x.txt
Bati-chave e interromper após aguardar por algum tempo.

amostra do ficheiro x.txt conteúdo:
1221785538 [1,99]
1221785538 [1,99]
1221785538 [1,99]


Então, para ver quantas vezes sistema foi capaz de executá-lo eu:
$ Cut-c-12 x.txt | uniq-c

amostra de saída:
616 1221785538
615 1221785539
612 1221785540

Tels-me que o sistema é capaz de executar este processo simples apenas cerca de 600 vezes por segundo.

Só para ser coerente Gostaria de repetir aqui os resultados:
PIII no Linux -- 900 vezes / seg
Xeon 3/2 Linux -- 600 vezes / seg
Xeon 3/2 SCO -- 1800 vezes / seg
Os sistemas são inativo no momento do teste.
Como você explica os resultados eu tenho? Estou tentando achar um ponto de estrangulamento na moderna h / w correr Linux.

Por favor, veja o meu novo código simplificado abaixo:

 
#include <stdio.h>
#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/sem.h>
#include <time.h>
#define NSEMS   2
main(int argc, char *argv[])
{
  int           sid;
  ushort        vals[NSEMS] = {0, 0};
        if((sid = semget(get_ipc_key(), NSEMS, 0)) == -1)
        {
                errexit("Can Not Get Semaphore ID");
        }
        if(semctl(sid, NSEMS, GETALL, vals) == -1)
        {
                errexit("Can Not Get Semaphore Values");
        }
        printf("%12li [%i,%i]\n", time(NULL), vals[0], vals[1]);
        exit(0);
}