Fun-Soft - Programmierforum

Autor

Thread - Seiten: > 1 <

000
07.10.2004, 09:49 Uhr
~Fox
Gast

Also ich habe eine 512 Bit Variable aus einer Struktur gepuzzelt:

Code:

typedef struct
{
unsigned long long int part1;
unsigned long long int part2;
unsigned long long int part3;
unsigned long long int part4;
unsigned long long int part5;
unsigned long long int part6;
unsigned long long int part7;
unsigned long long int part8;
} gbit_t;

Ich lese sie aus einer Char Variable (Hexadezimale Zeichen) ein (Zu jeweils 64 bit). Bitoperatoren funktionieren ja, aber wie soll Multiplikation/Division und Addition/Subtraktion funktionieren?

Dieser Post wurde am 07.10.2004 um 09:50 Uhr von Fox editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

001
07.10.2004, 13:11 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)

das gibts nicht fertig das musst du wenn alles von hand selber proggen...

vom prinzip her so und so

es gibt aber auch schon feritg klassen mit eigenen datentypen für solche operationen...
da werden die zahlen imho als strings abgebildet...
hab jetzt aber spontan kein link dazu
--
...fleißig wie zwei Weißbrote

Dieser Post wurde am 07.10.2004 um 13:12 Uhr von Windalf editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

002
07.10.2004, 14:27 Uhr
~Fox
Gast

Die Funktionen die in den Threads beschrieben sind, muss ich die aus alle 8 Teile anwenden?

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

003
07.10.2004, 15:02 Uhr
Windalf
Der wo fast so viele Posts wie FloSoft...
(Operator)

Die Funktionen selber kannst du so nicht benutzen... du musst die addition und multiplikation selber so wie im thread beschrieben implementieren... also überträge merken und dann zum nächsten bit schieben....
ist nicht gerade ne freude und ich würde eher empfehlen eine fertige klasse die es irgendwo runterzuladen gibt zu verwenden... Irgendwo im Forum waren auch links dazu, kannst ja mal die Forumssuche bemühen...
--
...fleißig wie zwei Weißbrote

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

004
07.10.2004, 15:33 Uhr
~Fox
Gast

Ich kenn nur GMP und die ist nicht gerade schnell.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

005
07.10.2004, 18:24 Uhr
~Fox
Gast

Naja sind die Funktionen (die nur mit Bitoperatoren) eigentlich schneller als Standart Rechenoperationen?

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

006
07.10.2004, 19:11 Uhr
Hans
Library Walker
(Operator)

Zitat von Fox:

Naja sind die Funktionen (die nur mit Bitoperatoren) eigentlich schneller als Standart Rechenoperationen?

Hi,

das könnte durchaus möglich sein, da die Rechenoperationen ja auch aus Logikfunktionen gebildet werden, wie an anderer Stelle hier im Forum schon beschrieben.
Um festzustellen was schneller ist, schreibst Du am besten beide Varianten der Funktionen, und lässt sie so etwa hunderttausend bis eine Millionen mal durchlaufen, wobei Du (bzw. Dein Testprogramm) jeweils die Zeit stoppst, die dafür nötig ist.

Hans
--
Man muss nicht alles wissen, aber man sollte wissen, wo es steht. Zum Beispiel hier: Nachdenkseiten oder Infoportal Globalisierung.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

007
07.10.2004, 19:14 Uhr
~Fox
Gast

Ja ok mach ich mal.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

008
07.10.2004, 19:35 Uhr
~Fox
Gast

So am Start bei der Multiplikation waren 2 Varianten:
1.

Code:

#include <stdio.h>
#include <time.h>

inline int m(register int n, register int f){
register int i,r;
for(i=r=0;f;f>>=1,++i)
{
r+=f%2?n<<i:0;
}
return r;
}

int main (void)
{
register int c=0;
register int x=0;
register int y=0;
register int z=1000000;
register clock_t later, now;
register double passed;
now = clock ();
while (c<=z)
{
m (x,y);
x++;
y++;
c++;
}
later = clock ();
passed = ( later - now ) / (double)CLOCKS_PER_SEC;
printf( "%g",passed );
return 0;
}

Ergebnis = 0.28

2.

Code:

#include <stdio.h>
#include <time.h>

inline int m(register int n, register int f){
return n*f;
}

int main (void)
{
register int c=0;
register int x=0;
register int y=0;
register int z=1000000;
register clock_t later, now;
register double passed;
now = clock ();
while (c<=z)
{
m (x,y);
x++;
y++;
c++;
}
later = clock ();
passed = ( later - now ) / (double)CLOCKS_PER_SEC;
printf( "%g",passed );
return 0;
}

Ergebnis = 0.1

Bei der Addition:

1.

Code:

#include <stdio.h>
#include <time.h>

inline int addiere(register int x, register int y)
{
register int s1 = x^y;
register int s2 = x&y;
if (s2) return(addiere(s2 << 1, s1)); else return(s1);
}

int main (void)
{
register int c=0;
register int x=0;
register int y=0;
register int z=1000000;
register clock_t later, now;
register double passed;
now = clock ();
while (c<=z)
{
addiere (x,y);
x++;
y++;
c++;
}
later = clock ();
passed = ( later - now ) / (double)CLOCKS_PER_SEC;
printf( "%g",passed );
return 0;
}

Ergebnis = 0.2

2.

Code:

#include <stdio.h>
#include <time.h>

inline int addiere(register int x, register int y)
{
return x+y;
}

int main (void)
{
register int c=0;
register int x=0;
register int y=0;
register int z=1000000;
register clock_t later, now;
register double passed;
now = clock ();
while (c<=z)
{
addiere (x,y);
x++;
y++;
c++;
}
later = clock ();
passed = ( later - now ) / (double)CLOCKS_PER_SEC;
printf( "%g",passed );
return 0;
}

Ergebnis = 0.01;

Also, wer hätte es gedacht

, haben die native Operatoren gewonnen

Dieser Post wurde am 07.10.2004 um 19:37 Uhr von Fox editiert.

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

009
07.10.2004, 19:43 Uhr
~Fox
Gast

Hier nochmal für alle Assembler Freaks der Assembler Code zum austoben:

Multiplikation:

Code:

    .file    "k.c"
    .text
.globl m
    .type    m, @function
m:
    pushl    %ebp
    movl    %esp, %ebp
    subl    $8, %esp
    movl    $0, -8(%ebp)
    movl    $0, -4(%ebp)
.L2:
    cmpl    $0, 12(%ebp)
    je    .L3
    movl    12(%ebp), %eax
    andl    $1, %eax
    testl    %eax, %eax
    je    .L4
    movl    8(%ebp), %eax
    movzbl    -4(%ebp), %ecx
    sall    %cl, %eax
    addl    %eax, -8(%ebp)
.L4:
    sarl    12(%ebp)
    incl    -4(%ebp)
    jmp    .L2
.L3:
    movl    -8(%ebp), %eax
    leave
    ret
    .size    m, .-m
    .section    .rodata
.LC1:
    .string    "%g"
    .align 8
.LC0:
    .long    0
    .long    1093567616
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    subl    $40, %esp
    andl    $-16, %esp
    movl    $0, %eax
    addl    $15, %eax
    addl    $15, %eax
    shrl    $4, %eax
    sall    $4, %eax
    subl    %eax, %esp
    movl    $0, -4(%ebp)
    movl    $0, -8(%ebp)
    movl    $0, -12(%ebp)
    movl    $1000000, -16(%ebp)
    call    clock
    movl    %eax, -20(%ebp)
.L8:
    movl    -16(%ebp), %eax
    cmpl    %eax, -4(%ebp)
    jg    .L9
    movl    -12(%ebp), %eax
    movl    %eax, 4(%esp)
    movl    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    m
    incl    -8(%ebp)
    incl    -12(%ebp)
    incl    -4(%ebp)
    jmp    .L8
.L9:
    call    clock
    subl    -20(%ebp), %eax
    pushl    %eax
    fildl    (%esp)
    leal    4(%esp), %esp
    fldl    .LC0
    fdivrp    %st, %st(1)
    fstpl    4(%esp)
    movl    $.LC1, (%esp)
    call    printf
    movl    $0, %eax
    leave
    ret
    .size    main, .-main
    .section    .note.GNU-stack,"",@progbits
    .ident    "GCC: (GNU) 3.4.2"

Addition:

Code:

    .file    "k.c"
    .text
.globl addiere
    .type    addiere, @function
addiere:
    pushl    %ebp
    movl    %esp, %ebp
    subl    $20, %esp
    movl    8(%ebp), %edx
    movl    12(%ebp), %eax
    movl    %edx, %ecx
    xorl    %eax, %ecx
    movl    %ecx, -8(%ebp)
    andl    %eax, %edx
    movl    %edx, -12(%ebp)
    cmpl    $0, -12(%ebp)
    je    .L2
    movl    -8(%ebp), %eax
    movl    %eax, 4(%esp)
    movl    -12(%ebp), %eax
    addl    %eax, %eax
    movl    %eax, (%esp)
    call    addiere
    movl    %eax, -4(%ebp)
    jmp    .L1
.L2:
    movl    -8(%ebp), %ecx
    movl    %ecx, -4(%ebp)
.L1:
    movl    -4(%ebp), %eax
    leave
    ret
    .size    addiere, .-addiere
    .section    .rodata
.LC1:
    .string    "%g"
    .align 8
.LC0:
    .long    0
    .long    1093567616
    .text
.globl main
    .type    main, @function
main:
    pushl    %ebp
    movl    %esp, %ebp
    subl    $40, %esp
    andl    $-16, %esp
    movl    $0, %eax
    addl    $15, %eax
    addl    $15, %eax
    shrl    $4, %eax
    sall    $4, %eax
    subl    %eax, %esp
    movl    $0, -4(%ebp)
    movl    $0, -8(%ebp)
    movl    $0, -12(%ebp)
    movl    $1000000, -16(%ebp)
    call    clock
    movl    %eax, -20(%ebp)
.L5:
    movl    -16(%ebp), %eax
    cmpl    %eax, -4(%ebp)
    jg    .L6
    movl    -12(%ebp), %eax
    movl    %eax, 4(%esp)
    movl    -8(%ebp), %eax
    movl    %eax, (%esp)
    call    addiere
    incl    -8(%ebp)
    incl    -12(%ebp)
    incl    -4(%ebp)
    jmp    .L5
.L6:
    call    clock
    subl    -20(%ebp), %eax
    pushl    %eax
    fildl    (%esp)
    leal    4(%esp), %esp
    fldl    .LC0
    fdivrp    %st, %st(1)
    fstpl    4(%esp)
    movl    $.LC1, (%esp)
    call    printf
    movl    $0, %eax
    leave
    ret
    .size    main, .-main
    .section    .note.GNU-stack,"",@progbits
    .ident    "GCC: (GNU) 3.4.2"

Profil || Private Message || Suche

Download || Zitatantwort || Editieren || Löschen || IP

Seiten: > 1 < [ C / C++ (ANSI-Standard) ]

ThWBoard 2.73 FloSoft-Edition
© by Paul Baecher & Felix Gonschorek (www.thwboard.de)

Anpassungen des Forums
© by Flo-Soft (www.flo-soft.de)

Sie sind Besucher: