Je suis une enquête système de verrouillage utilisant des sémaphores. Pour évaluer la vitesse de base du système-je effectuer une boucle d'obtenir certaines informations sur la sémaphore et de l'afficher:

while:; faire. / semshow; done> res.txt

J'ai couru le 3 boîtes - deux analogues modernes HP Xeon boîtes, une course SCO OpenServer 5, l'autre est Fedora 2.6.9, et un vieux PIII boîte moderne sous Linux (ont pas d'info).
Les résultats sont très contre-intuitives:
H / W | OS | avg nombre de pistes bre sec
---- | --- | -------------------------
Xeon | SCO | 1700
Xeon | Fedora | 500
PIII | Linux (distribution récente, inconnu) | 900
Les trois systèmes sont à peu près au ralenti à l'essai du temps.

Je voudrais vous demander, quels seraient les facteurs qui ont fait de surperformer ancienne Unix OS modernes, également, comment se surpasser moderne boîte PIII Xeon boîte dans les mêmes OS. Toute ponters serait appréciée.

Semshow Le programme est très basique, voir la liste ci-dessous:

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

Voici une réponse: le temps de mesure est bogué. Voir l'homme sur ftime () sous Linux:

La boîte a Fedora
/lib/tls/libc.so.6 -> libc-2.3.5.so
oui, je suppose que la version 2.3.5.

Mais cela est d'ailleurs le point.

Le nombre de fois pur système d'exécution du programme au sein d'une seconde d'indiquer l'ensemble du système de pouvoir, pour ainsi dire. À mon grand étonnement PIII sous Linux a réussi à fonctionner presque deux fois plus de cycles d'une seconde que withi Xeon cadencé à 3,2 GHz sous Linux. Ensuite, la même Xeon h / w sous de vieux SCO OSR courir deux fois plus vite que PIII boîte.

Mais Problème # 1 est que l'on mesure ce la bonne façon. Vous avez un trop grand nombre de dépendances de la bibliothèque, les appels qui n'ont rien à ce que vous essayez de mesure. Prendre toutes les sémaphore code, re-test, et voir ce que vous obtenez fois. Ou de lancer une boucle autour de 10000 x sémaphore. Ensuite, réduire à la seconde près afin que les micro-mistimings ne viennent pas en jouer.

Problème n ° 2 est que les sémaphores exiger l'accès et le bus sont relativement indépendantes de la vitesse du processeur.

J'ai remplacé les ftime avec gettimeofday et de ré-exécuter, les résultats sont les mêmes.

Pour résumer,
même h / w:
programme sous SCO va 3 fois plus rapide que sous Linux,
même système d'exploitation:
programme fonctionne 2 fois plus rapide que sur de vieux PIII Xeon modernes

Les raisons? des idées?

Je suis désolé, mais vous n'avez toujours pas éliminé toutes les "variables loose". Mais votre code sémaphore dans une boucle de 1000 environ et banc de nouveau.

J'ai simplifié mon programme à la base minimum, il est ipc clé, id est sémaphore et lit les valeurs des sémaphores et puis il affiche sur la ligne (en temps et en sémaphore valeurs). C'est tout ce qu'il fait.

Puis-je exécuter en manière suivante:
$ While:; ne tstshow; done> x.txt
et je frappe clés interrompre après avoir attendu un certain temps.

échantillon de la x.txt contenu du fichier:
1221785538 [1,99]
1221785538 [1,99]
1221785538 [1,99]


Ensuite, pour voir combien de fois a été capable de le faire fonctionner que je fais:
$ Cut-c-12 x.txt | uniq-c

échantillon de la sortie:
616 1221785538
615 1221785539
612 1221785540

Tels que moi, le système est capable d'exécuter ce processus simple à seulement environ 600 fois par seconde.

Juste pour être cohérent, je le répète, les résultats ici:
PIII sous Linux -- 900 fois / sec
Xeon 3.2 sous Linux -- 600 fois / sec
Xeon 3.2 SCO -- 1800 fois / sec
Les systèmes sont inactifs au moment du test.
Comment expliquez-vous les résultats obtenus? J'essaie de trouver un goulet d'étranglement sur l'modernes h / w sous Linux.

S'il vous plaît voir mon nouveau code simplifié ci-dessous:

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