JLI Spieleprogrammierung Foren-Übersicht JLI Spieleprogrammierung

 
 FAQFAQ   SuchenSuchen   MitgliederlisteMitgliederliste   BenutzergruppenBenutzergruppen 
 medals.phpMedaillen   RegistrierenRegistrieren   ProfilProfil   Einloggen, um private Nachrichten zu lesenEinloggen, um private Nachrichten zu lesen   LoginLogin 

auslastung des pc

 
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik
Vorheriges Thema anzeigen :: Nächstes Thema anzeigen  
Autor Nachricht
Faller
Junior JLI'ler


Alter: 37
Anmeldedatum: 30.11.2006
Beiträge: 88
Wohnort: Dresden
Medaillen: Keine

BeitragVerfasst am: 21.01.2007, 15:45    Titel: auslastung des pc Antworten mit Zitat

Ich habe einen kleinen Cleint geschrieben (der soll nur zum testen sein) unter win 32 konsole wenn ich sie starte sie (0 Fehler 0 Warnings) dann springt die cpu auslastung sovort auf 100%. Bei jedem Rechner auf dem ich es getestet habe die funktionalität ist zwar gegeben aber das fertige spiel soll natürlich noch mehr beinhalten soweit ich es weis müsste es an dem select liegen aber da ich mir dieses Gebiet gerade erst aneigne weis ich das natürlich nicht so genau.
(der beste Comp hatte dualcore 2ghz klaube ich ne spizer graka und 1,5 gb ram)

der Cleint soll x yund z werte in einen string packen und dann an den Server versenden, Solten Daten herein kommen dann werden diese wieder aufgeschlüsselt und ausgegeben

und hier ist der Code
CPP:
#include <conio.h>
#include <string.h>
#include <windows.h>
#include <stdlib.h>



struct spielerstuktur
{

   float drehung;            //die spieler drehung
   float dreh_k;
   float sx,sy,sz;
};

struct ping_a
{
   short gesetzt;         //ob der überhaupt da ist
   char buffer[4048];      //der übergabe puffer für den jewaligen gener
   short a_ping;         //ping bis neue nachichten empfangen werden
   short a_frame;
};
ping_a gegner[5];
spielerstuktur andere;
spielerstuktur test={0,0,20,0.234f,-100};
FILE *d;
 

char* umwandeln(float ein)
{
   char *umgewandelt=0;
   char null[5]={0};
   int i=0;
   int precision = 7;
   
   int decimal, sign;
   if(ein>10.0f)
      precision = 8;
   if(ein>100.0f)
      precision = 9;
   if(ein>1000.0f)
      precision = 10;
   if(ein>10000.0f)
      precision = 11;
   //in die minus richtung
   if(ein<-10.0f)
      precision = 8;
   if(ein<-100.0f)
      precision = 9;

   //strcat(zahl,umgewandelt);


   umgewandelt = _ecvt(ein, precision, &decimal, &sign);


      for(i=precision;i>decimal-1;i--)
      {
         umgewandelt[i+1]=umgewandelt[i];
      }
      umgewandelt[decimal]='.';
   if(ein<1&&ein>0)
   {
   
      for(i=precision+1;i>0;i--)
      {
         umgewandelt[i+1]=umgewandelt[i];
      }
      umgewandelt[0]='0';
      umgewandelt[1]='.';
      umgewandelt[precision+1]='\0';
      //printf("test");
   }
   if(ein<0)
   {
      for(i=precision+1;i>-1;i--)
      {
         umgewandelt[i+1]=umgewandelt[i];
      }
      umgewandelt[0]='-';
      
      //umgewandelt[precision+1]='\0';
   }
   
   
//   printf("die zahl: %f\n", ein);
//   printf("buffer: |%s'\n", umgewandelt);

   return umgewandelt;
}

void leeren_string(char * string)
{
   int i=0;
   for (i=0;i<20;i++)
      string[i]=0;
}

void posi_g(int ab,int wer)//der buffer wo alle drinne sthet ,ab abwo das ausgelesen werden soll,wer wer haier das macht
{
   char string[20]={0},c=0;
   int i=0;
   int posi=ab;

   //posi++;
      while(c!=',')
      {
         c=gegner[wer].buffer[posi];
         string[i]=gegner[wer].buffer[posi];
         i++;
         posi++;
      }
      //der x wert des gegners
      andere.sx=(float)atof(string);
      c=0;
      i=0;
      leeren_string(string);
      while(c!=',')
      {
         c=gegner[wer].buffer[posi];
         string[i]=gegner[wer].buffer[posi];
         i++;
         posi++;
      }
      //der y wert des gegners
      andere.sy=(float)atof(string);
      c=0;
      i=0;
      leeren_string(string);
      while(c!=',')
      {
         c=gegner[wer].buffer[posi];
         string[i]=gegner[wer].buffer[posi];
         i++;
         posi++;
      }
      //der z wert des gegners
      andere.sz=(float)atof(string);
}

void ob_gegner_da()
{
   
   int aktuel_zu=0,i=0,j=0;
   d=fopen("protokoll.txt","a+");
   
   for(j=0;j<5;j++)
   {
      if(gegner[j].gesetzt==1)
      {
         
         gegner[j].a_frame++;
         if(gegner[j].a_ping<gegner[j].a_frame)
         {
            printf("lack von %i \n",j);
            fprintf(d,"lack von %i \n",j);
            gegner[j].a_frame=gegner[j].a_ping;
         }
         else
         {
            for(aktuel_zu=0;aktuel_zu<gegner[j].a_frame;aktuel_zu++)
            {
               i++;
               while(gegner[j].buffer[i]!='f')
               {
                  i++;
               }
            }
            i=i+2;
            posi_g(i,j);
            printf("past der z wert von %i ist %f\n",j,andere.sz);
            fprintf(d,"past der z wert von %i ist %f\n",j,andere.sz);
            //test=i;
            
         }
         
      }
      i=0;
   }
   fclose(d);
   
}


int main()
{

   SOCKET s;
   SOCKADDR_IN addr;
   char c=0;
   char buf[4048]={0},string[20]={0}; //für eingehenden daten
   //char inpBuf[1024]={0};
   //int inpBufPos=0;
   fd_set fdSetRead;
   TIMEVAL timeout;
   int rc=0;
   int i=0;
   int nr=0;
   int zw=0;  //der zwischen speicher für denn ping
   int wann_senden=0;

   //für die zahlen
   
   char *buffer=0,strzahl[200]={0}; //buffer ist zum senden da
// Framerate festlegen - Werte zwischen 25 und
   // der Bildwiederholfrequenz sind sinvoll
   int Framerate = 60;


   LONGLONG Frequency; // Frequenz des Counters
   LONGLONG Offset;    // Abstand zwischen den Frames
   LONGLONG NextFrame; // Zeit bis zum nächsten Frame
   LONGLONG CurCount;  // aktueller Zählerstand


   d=fopen("protokoll.txt","w");
   fclose(d);
   
   WSADATA wsa;
   if (WSAStartup(MAKEWORD(1, 1), &wsa))
   {
      printf("WSAStartup() failed, %lu\n", (unsigned long)GetLastError());
      return EXIT_FAILURE;
   }



       
   // addr vorbereiten, hostname auflösen

   memset(&addr,0,sizeof(SOCKADDR_IN));
   addr.sin_family=AF_INET;
   addr.sin_port=htons(6112);
   addr.sin_addr.s_addr = inet_addr("127.0.0.1");


   // socket erstellen

   s=socket(PF_INET,SOCK_STREAM,0);
   if(s==INVALID_SOCKET) {
      printf("Error, cannot create socket: %d\n",WSAGetLastError());
      return 1;
   }

   // verbinden..

   printf("Connecting...\n");
   rc=connect(s,(SOCKADDR*)&addr,sizeof(SOCKADDR));
   if(rc==SOCKET_ERROR) {
      printf("Error: connect failed: %d\n",WSAGetLastError());
      return 1;
   }

   printf("\n");
   // Frequenz speichern, wenn Counter vorhanden
    if(!QueryPerformanceFrequency(
                   (LARGE_INTEGER*)&Frequency))
    {
        MessageBox(0,"Performancecounter nicht vorhanden.","Fehler",MB_OK);
        return -1;
    }

    // Abstand zwischen zwei Frames berechnen
    Offset = Frequency / Framerate;

    // aktuellen Zählerstand Zeit speichern
    QueryPerformanceCounter((LARGE_INTEGER*)&CurCount);

    // berechnen wann nächstes Frame dargestellt wird
    NextFrame = CurCount + Offset;

   
   
   while(rc!=SOCKET_ERROR)
   {
   
      // keyboard input ?
      //rc=send(s,zahl,strlen(zahl),0);
      // aktuellen Zählerstand holen
        QueryPerformanceCounter((LARGE_INTEGER*)&CurCount);

      // fd_set und timeout vorbereiten

      FD_ZERO(&fdSetRead);
      FD_SET(s,&fdSetRead);
      timeout.tv_sec=0;
      timeout.tv_usec=0;
           
        // wenn es Zeit für das nächste Frame ist
            if(CurCount > NextFrame)
         {
            wann_senden++;
            // Abstand zum nächsten Frame berechnen
                NextFrame = CurCount + Offset;
            test.sz+=0.03f;
            if(wann_senden==5)
            {
               wann_senden=0;
               strcpy(strzahl,"");
               strcat(strzahl,",f,");
               buffer=umwandeln(test.sx);
               strcat(strzahl,buffer);
               strcat(strzahl,",");
               buffer=umwandeln(test.sy);
               strcat(strzahl,buffer);
               strcat(strzahl,",");
               buffer=umwandeln(test.sz);
               strcat(strzahl,buffer);
               strcat(strzahl,",");
               printf("senden \n",strzahl);
               //test.sz-=0.03f*10;
               rc=send(s,strzahl,strlen(strzahl),0);
               ob_gegner_da();
               //printf("gesendet %s\n",strzahl);


            }

               // prüfen ob ein socket bereit ist, da timeout=0 kehrt die funktion
              // sofort wieder zurück nach dem aufruf.
              // achtung: das timeout auf 0 setzen oder als paremeter NULL mitgeben
              // ist NICHT das gleiche. auf 0 gesetzt kehrt sofort zurück, während
               
              while((rc=select(0,&fdSetRead,NULL,NULL,&timeout))>0)
              {
                  rc=recv(s,buf,4047,0);
                  // server hat die verbindung beendet ?
                  if(rc==0)
                  {
                     printf("Server closed connection!\n");
                     return 1;
                  // fehler: beenden!
                  }
                  else if(rc==SOCKET_ERROR)
                  {
                     printf("Error: recv failed: %d\n",WSAGetLastError());
                     return 1;
                  }

                  // empfangene daten

                  buf[rc]='\0';
                  //wer sendet
                  while(c!=',')
                  {
                     c=buf[i];
                     string[i]=buf[i];
                     i++;
                  }
                  //die cleintnummer
                  nr=atoi(string);
                  zw=0;
                  //gugen ob der cleint tot ist
                  for(i=0;i<rc;i++)
                  {
                     if(buf[i]=='t')
                     {
                        gegner[nr].gesetzt=0;
                        c='t';
                     }
                     if(buf[i]=='f')
                     {
                        zw++;
                     }
                  }
                  //wenn der cleint net tot ist dann
                  if(c!='t')
                  {
                     i=0;
                     c=0;
                     gegner[nr].gesetzt=1;
                     gegner[nr].a_ping=0;
                     strcpy(gegner[nr].buffer,buf);
                     gegner[nr].a_ping=zw;
                     gegner[nr].a_frame=0;
                  }
               
                  
              }
         }

       
       


       
       
   }

   // aufräumen
   closesocket(s);
   WSACleanup();
   printf("Client shutdown, press any key to exit\n");
   
   getch();
   return 0;
}



für jede ander Verbesserung binn ich natürlich offen
_________________
versuche alles nur wann und wie ist die frage
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
Jonathan_Klein
Living Legend


Alter: 37
Anmeldedatum: 17.02.2003
Beiträge: 3433
Wohnort: Siegerland
Medaillen: Keine

BeitragVerfasst am: 21.01.2007, 16:45    Titel: Antworten mit Zitat

Evtl. hilft die sleep Anweidung, damit sagst du Windows, das es auch Rechenzeit auf andere Processe vergeben soll.
Wenn du in einer Schleife nur auf etwas wartest solltest du da Sleep(Zeit in Millisekunden); reinschreiben, dann ist die Auslastung auch nicht mehr so hoch.
Achja und bitte [ cpp ] statt [ code ] verwendne, das kann man viel besser lesen.
_________________
https://jonathank.de/games/
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Faller
Junior JLI'ler


Alter: 37
Anmeldedatum: 30.11.2006
Beiträge: 88
Wohnort: Dresden
Medaillen: Keine

BeitragVerfasst am: 21.01.2007, 17:33    Titel: Antworten mit Zitat

Danke selbst bei Sleep(1);
Ist die cpu auslastung nurnoch 3 % thx
und close
_________________
versuche alles nur wann und wie ist die frage
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden
AFE-GmdG
JLI MVP
JLI MVP


Alter: 45
Anmeldedatum: 19.07.2002
Beiträge: 1374
Wohnort: Irgendwo im Universum...
Medaillen: Keine

BeitragVerfasst am: 22.01.2007, 08:27    Titel: Antworten mit Zitat

Ich würde sagen, dass es sich bei dem Problem mit der Prozessorlast um einen Designfehler handelt.
Zuerst verwendest du eine Endlosschleife ohne Möglichkeit für Prozesse, umzuschalten und dann schränkst du die "Frame"Senderate künstlich ab, indem du nur jeden 5. Durchlauf überhaupt sendest.
Statt Nonblocking beim Senden / Empfangen zu nutzen sollte man sich vielleicht auf blockierende Funktionen mit Timeout (z.B. 25 ms, das wären innernoch 40 FPS) umschwenken. Wenn diese Funktionen Blockieren, wird keine Prozessorlast verbraucht und der Prozessor kann in der zwischenzeit andere Prozesse bearbeiten.
_________________
CPP:
float o=0.075,h=1.5,T,r,O,l,I;int _,L=80,s=3200;main(){for(;s%L||
(h-=o,T= -2),s;4 -(r=O*O)<(l=I*I)|++ _==L&&write(1,(--s%L?_<(L)?--_
%6:6:7)+\"World! \\n\",1)&&(O=I=l=_=r=0,T+=o /2))O=I*2*O+h,I=l+T-r;}
Nach oben
Benutzer-Profile anzeigen Private Nachricht senden E-Mail senden Website dieses Benutzers besuchen
Beiträge der letzten Zeit anzeigen:   
Neues Thema eröffnen   Neue Antwort erstellen    JLI Spieleprogrammierung Foren-Übersicht -> Fragen, Antworten und Kritik Alle Zeiten sind GMT
Seite 1 von 1

 
Gehe zu:  
Du kannst keine Beiträge in dieses Forum schreiben.
Du kannst auf Beiträge in diesem Forum nicht antworten.
Du kannst deine Beiträge in diesem Forum nicht bearbeiten.
Du kannst deine Beiträge in diesem Forum nicht löschen.
Du kannst an Umfragen in diesem Forum nicht mitmachen.


Powered by phpBB © 2001, 2005 phpBB Group
Deutsche Übersetzung von phpBB.de

Impressum