Én nyomozó néhány reteszelő rendszert használó szemafor. Hogy értékeljék az alapvető rendszer sebességét Én vezetem a hurok egyre szemaforhoz néhány információ és megjeleníteni a következő:

közben:; do. / semshow; Kész> res.txt

Futottam ezt 3 doboz - két hasonló modern HP Xeon doboz, egy futó SCO OpenServer 5, a másik a Fedora 2.6.9, és egy régi PIII rovat alatt modern Linux (nincs info).
Az eredmények nagyon intuitív számláló:
H / W | OS | avg száma fut ber sec
---- | --- | -------------------------
Xeon | SCO | 1700
Xeon | Fedora | 500
PIII | Linux (újabb distro ismeretlen) | 900
Mindhárom rendszerek nagyon sok üresjárat a vizsgálati időt futni.

Azt szeretném kérdezni, mi lenne a tényező, amely az ősi Unix teljesítenek a modern OSes is, hogy hogyan jön PIII doboz teljesítenek modern Xeon doboz hasonló OS. Minden ponters lenne méltányol.

A semshow program nagyon egyszerű, lásd a tőzsdei alább:

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

Itt van egy válasz: Az idő mérése hibás. Lásd az ember ftime () Linux alatt:

A Fedora doboz
/lib/tls/libc.so.6 -> libc-2.3.5.so
igen, feltételezem, a verzió 2.3.5.

De ez az a pont mellett.

A tiszta hányszor rendszer futott a program egy másik azt jelzi, a teljes rendszer a teljesítmény, hogy úgy mondjam. Az én meglepetten PIII Linux alatt sikerült távon csaknem kétszer annyi a második ciklust withi Xeon 3.2GHz, mint Linux alatt. Ezután az azonos Xeon h / w alapján régi SCO OSR távon kétszer olyan gyors, mint PIII mezőbe.

De Probléma # 1 az, hogy Ön erre a rossz irányba. Túl sok a könyvtár felszólítja a függőségek, hogy lényegtelen, hogy mit próbálnak mérni. Vegye ki minden szemafor kód, re-test, és milyen idő lesz. Vagy, fuss egy 10.000 x hurok körül szemaforhoz. Akkor skálán lefelé, a legközelebbi második hogy microseconds mistimings nem jön játékba.

A probléma az, hogy a # 2 szemaforok igényelnek autóbusz-hozzáférés és viszonylag független a processzor sebességét.

I helyébe a ftime a gettimeofday, és újra futni az eredmény ugyanaz.

Összefoglalva ismét
ugyanolyan h / w:
programot futtat SCO 3-szor gyorsabb, mint a Linux,
Ugyanez OS:
program fut, 2-szer gyorsabb a régi PIII, mint a modern Xeon

Minden oka? any ideas?

Sajnálom, de még mindig nem szüntette meg az összes "laza változókat". De a szemafor kódot hurok az 1000 vagy a padon, és így újra.

Azt én egyszerűsített programot a legalapvetőbb minimum, hogy kap ipc gombot, kap szemaforhoz id és olvasás értékeit szemaforok majd outputs on-line (idő és a szemafor érték). Ez mind így van.

Majd futtassa a következő módon:
$ Közben:; do tstshow; Kész> x.txt
és én félbe hit legfontosabb várakozás után egy ideig.

mintát a x.txt fájl tartalma:
1221785538 [1,99]
1221785538 [1,99]
1221785538 [1,99]


Azután, hogy hányszor rendszer működtetése érdekében, hogy én:
$ Cut-c-12 x.txt | Uniq-c

mintát a teljesítmény:
616 1221785538
615 1221785539
612 1221785540

Tels nekem, hogy a rendszer képes működni, ez az egyszerű eljárás csak nagyjából 600-szer per pillanat.

Csak ha azt szeretném megismételni eredményeit itt:
PIII Linux alatt -- 900 szer / sec
Xeon 3,2 Linux -- 600 szer / sec
Xeon 3,2 SCO -- 1800 szer / sec
Rendszerek üresjáratban idején a vizsgálat.
Hogyan magyarázzák az eredményeket Megvan? Próbálom megtalálni a szűk keresztmetszetet a modern h / w futó Linux.

Kérjük, az én új, egyszerűsített kódot a következők:

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