Ik ben enkele vergrendeling regeling gebruik van semaforen. Te evalueren basisstelsel snelheid ik een lus om enkele semafoor info en weer te geven:

terwijl:; doen. / semshow; gedaan> res.txt

Ik heb dit op 3 dozen - twee soortgelijke moderne HP XEON dozen, een stromend SCO OpenServer 5, de andere is Fedora 2.6.9, en een oude PIII vak onder moderne Linux (geen info).
De resultaten zijn zeer intuïtief teller:
H / W | OS | Gem aantal loopt ber sec
---- | --- | -------------------------
XEON | SCO | 1700
XEON | Fedora | 500
PIII | Linux (recente distro, onbekend) | 900
Alle drie de systemen waren vrijwel stationair op de test tijd.

Ik zou willen vragen, wat zouden de factoren die oude Unix te presteren moderne besturingssystemen, ook, hoe komt het PIII vak presteren moderne XEON vak onder soortgelijke OS. Elke ponters zou worden gewaardeerd.

De semshow programma is zeer basic, zie hieronder:

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

Hier is een antwoord: uw tijd meting buggy. Zie man op ftime () onder Linux:

Het Fedora vak heeft
/lib/tls/libc.so.6 -> libc-2.3.5.so
ja, ik neem de versie is 2.3.5.

Maar dat is naast het punt.

De zuivere aantal keer systeem liep het programma binnen een seconde zou geven totale systeem de macht, om zo te zeggen. Tot mijn verbazing PIII onder Linux te draaien bijna tweemaal zoveel cycli withi een seconde dan Xeon 3.2GHz onder Linux. Dan dezelfde Xeon h / w onder de oude SCO OSR lopen twee keer zo snel als PIII doos.

Maar Probleem # 1 is dat je de meting dit de verkeerde manier. U hebt te veel afhankelijkheden van bibliotheek telefoontjes die niet relevant zijn voor wat je probeert te meten. Neem alle semaphore code, re-test en zie welke tijden je krijgt. Of, op een 10.000 x lus rond de semafoor. Dan schaal naar de dichtstbijzijnde tweede zodat microseconden mistimings niet in het spel.

Probleem # 2 is dat semaforen nodig bus-toegang en zijn relatief onafhankelijk van de processor snelheid.

Ik verving de ftime met gettimeofday en opnieuw uit te voeren, de resultaten zijn hetzelfde.

Om samen te vatten opnieuw
dezelfde h / w:
programma onder SCO loopt 3 keer sneller dan onder Linux,
hetzelfde OS:
programma draait 2 keer sneller op oude PIII dan op moderne Xeon

Eventuele redenen? Any ideas?

Het spijt me, maar je nog steeds niet weggewerkt alle "losse variabelen". Maar je semafoor-code in een loop van 1000 of zo en bankje opnieuw.

Ik vereenvoudigde mijn programma naar de zeer minimum, het wordt ipc toets, krijgt semaphore id en leest de waarden van semaforen en vervolgens uitgangen op lijn (tijd en semafoor waarden). Dat is alles wat zij doet.

Daarna heb ik het draaien op de volgende manier:
$ Terwijl:; doen tstshow; gedaan> x.txt
en ik hit onderbreken sleutel wachten na enige tijd.

monster van het x.txt bestandsinhoud:
1221785538 [1,99]
1221785538 [1,99]
1221785538 [1,99]


Dan is te zien hoeveel keer systeem in staat was om het uit te voeren ik doen:
$ Cut-c-12 x.txt | uniq-c

monster van de output:
616 1221785538
615 1221785539
612 1221785540

Tels me dat het systeem in staat is om draait dit eenvoudige proces slechts ongeveer 600 keer per seconde.

Gewoon om consistent te zijn zou ik herhaal resultaten hier:
PIII onder Linux -- 900 keer / sec
Xeon 3.2 Linux -- 600 keer / sec
Xeon 3.2 SCO -- 1800 keer / sec
Systemen zijn nutteloos op het moment van de test.
Hoe zou u uitleg over de resultaten kreeg ik? Ik ben op zoek naar een knelpunt op de moderne h / w Linux.

Zie mijn nieuwe vereenvoudigde code hieronder:

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