Jag undersöker några låsa systemet med hjälp av semaforer. Att utvärdera grundläggande systemet hastighet jag köra en slinga för att få några semaforen info och visa den:

samtidigt:; göra. / semshow; gjort> res.txt

Jag har kört på 3 lådor - två liknande moderna HP Xeon lådor, en kör SCO OpenServer 5, den andra är Fedora 2.6.9 och en gammal PIII rutan under modern Linux (har någon info).
Resultaten är mycket motverka intuitiv:
H / W | OS | avg antalet körningar ber sek
---- | --- | -------------------------
Xeon | SCO | 1700
Xeon | Fedora | 500
PIII | Linux (senaste distributioner, okända) | 900
Alla tre systemen var ganska inaktiv på provmätningen temne.

Jag skulle vilja fråga, vad skulle de faktorer som gör antika Unix överträffa moderna OSes också, hur kommer PIII fält överträffa moderna Xeon rutan under liknande OS. Alla ponters skulle uppskattas.

Den semshow program är mycket grundläggande, se lista nedan:

 
#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;
};

Här är ett svar: din tid är felaktig. Se människan på ftime () under Linux:

Fedora fält har
/lib/tls/libc.so.6 -> libc-2.3.5.so
ja, jag utgår från den version 2.3.5.

Men det är vid sidan av poängen.

Den rena antal gånger systemet drev program inom andra skulle ange övergripande system makt, så att säga. Till min förvåning PIII under Linux lyckades köra nästan dubbelt så många cyklar withi ett andra än Xeon 3.2GHz under Linux. Sedan samma Xeon h / v under gamla SCO OSR köra dubbelt så snabbt som PIII rutan.

Men Problem # 1 är att man mäter det här på fel sätt. Du har för många beroenden på biblioteket samtal som är irrelevanta för det du försöker att mäta. Ta bort alla semaforen kod nytt test, och se vilka tider du får. Eller köra en 10.000x slinga runt semaforen. Sedan skala ner till närmaste andra så att mikrosekunder mistimings inte kommer in i bilden.

Problem # 2 är att semaforer kräver buss-tillgång och är relativt oberoende av Processor hastighet.

Jag ersatte ftime med gettimeofday och kör, resultaten är desamma.

Sammanfattningsvis igen
samma h / v:
program enligt SCO går 3 gånger snabbare än under Linux,
samma OS:
körs 2 gånger snabbare om gamla PIII än på moderna Xeon

Alla skäl? några idéer?

Jag är ledsen, men du har fortfarande inte avskaffat alla "lös variabler. Men din semaforen kod i en loop av 1000 eller så och bänken igen.

Jag förenklade mitt program till mycket grundläggande minimum, det blir IPC nyckel får semaforen id och läser värden av semaforer och då är det utgångar på rad (temne och semaforen värden). Det är allt den gör.

Då ska jag köra det på följande sätt:
$ Samtidigt:; göra tstshow; gjort> x.txt
och jag drabbades avbryta nyckel efter väntar en tid.

urval av de x.txt fil innehåll:
1221785538 [1,99]
1221785538 [1,99]
1221785538 [1,99]


Sen att se hur många gånger som kunde köra det jag gör:
$ Cut-c-12 x.txt | Uniq-c

urval av resultaten:
616 1221785538
615 1221785539
612 1221785540

Det tels mig systemet klarar av att driva detta enkelt bara ungefär 600 gånger per sekund.

Bara för att vara konsekvent skulle jag upprepa resultaten här:
PIII under Linux -- 900 ggr / sek
Xeon 3.2 Linux -- 600 ggr / sek
Xeon 3.2 SCO -- 1800 ggr / sek
Systems är inaktiv vid tiden för testet.
Hur skulle du förklara de resultat som jag har? Jag försöker att hitta en flaskhals på den moderna h / w som kör Linux.

Se min nya förenklade koden nedan:

 
#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);
}