C에서 이상한 계산 문제가 1.2로 곱하면 실패합니다.

Question

나는이 코드를 가지고 있는데, 어디에서 오랫동안 dobule을 계산해야합니까.

double result; 
long t2_value; 

t2_value = 72; 
result = t2_value * 1.2; 

이제이 코드는 "result = t2_value * 1.2;"에서 충돌합니다. "Vector 0000000006"오류 만 있습니다. 내가

와

result = t2_value * 1.2; 

를 교체 할 경우 다음

는

result = 72 * 1.2; 

evything는 이중

result = ((double)t2_value * 1.2); 

로 그냥 예상대로, 내가 tryed 한 타입 캐스팅 t2_value 작동, 이상한 일이

또는 int ittead를 길게 만들지 만 아무 도움이되지 않습니다.

모든 코드는 기본 방법 /*을 참조하십시오. \ 파일 *이 \ 첫 번째 사용자의 프로그램 브리핑 - * */

#include <scwrapper.h> 


long thread_1_empty_semaphore_handle; 
long thread_1_mutex_semaphore_handle; 
long thread_1_full_semaphore_handle; 
long thread_2_empty_semaphore_handle; 
long thread_2_mutex_semaphore_handle; 
long thread_2_full_semaphore_handle; 

int debug; 

long value_thread_1; 
long value_thread_2; 


long send_port; 

void thread_1(void) 
{ 
    while(1) 
    { 
     long value; 

     if (ALL_OK != semaphoredown(thread_1_full_semaphore_handle)) 
      break; 

     if (ALL_OK != semaphoredown(thread_1_mutex_semaphore_handle)) 
      break; 

     // Generating some random number here and save it in value_thread_1 
     value_thread_1 = 91; 
     if(debug == 1) prints("Writing thread 1!\n"); 

     if (ALL_OK != semaphoreup(thread_1_mutex_semaphore_handle)) 
      break; 

     if (ALL_OK != semaphoreup(thread_1_empty_semaphore_handle)) 
      break; 
    } 
    terminate(); 
} 
void thread_2(void) 
{ 
    while(1) 
    { 
     long value; 

     if (ALL_OK != semaphoredown(thread_2_full_semaphore_handle)) 
      break; 

     if (ALL_OK != semaphoredown(thread_2_mutex_semaphore_handle)) 
      break; 

     // Generating some random number here and save it in value_thread_1 
     value_thread_2 = 72; 
     if(debug == 1) prints("Writing thread 2!\n"); 

     if (ALL_OK != semaphoreup(thread_2_mutex_semaphore_handle)) 
      break; 

     if (ALL_OK != semaphoreup(thread_2_empty_semaphore_handle)) 
      break; 
    } 
    terminate(); 
} 

int create_thread_1() 
{ 
    if(debug == 1) 
     prints("Creating thread 1!\n"); 
    register long thread_stack; 
    thread_1_empty_semaphore_handle=createsemaphore(16); 
    if (thread_1_empty_semaphore_handle<0) 
     return -1; 
    thread_1_full_semaphore_handle=createsemaphore(0); 
    if (thread_1_full_semaphore_handle<0) 
     return -1; 
    thread_1_mutex_semaphore_handle=createsemaphore(1); 
    if (thread_1_mutex_semaphore_handle<0) 
     return -1; 
    thread_stack=alloc(4096, 0); 
    if (0 >= thread_stack) 
     return -1; 
    if (ALL_OK != createthread(thread_1, thread_stack+4096)) 
     return -1; 
    return 1; 
} 
long read_tread_1() 
{ 
    long value = 0; 

    if (ALL_OK != semaphoredown(thread_1_empty_semaphore_handle)) 
     return -1; 

    if (ALL_OK != semaphoredown(thread_1_mutex_semaphore_handle)) 
     return -1; 

    value = value_thread_1; 
    if(debug == 1) 
     prints("Reading thread 1!\n"); 

    if (ALL_OK != semaphoreup(thread_1_mutex_semaphore_handle)) 
     return -1; 

    if (ALL_OK != semaphoreup(thread_1_full_semaphore_handle)) 
     return -1; 

    return value; 
} 

int create_thread_2() 
{ 
    if(debug == 1) 
     prints("Creating thread 2!\n"); 
    register long thread_stack; 
    thread_2_empty_semaphore_handle=createsemaphore(16); 
    if (thread_2_empty_semaphore_handle<0) 
     return -1; 
    thread_2_full_semaphore_handle=createsemaphore(0); 
    if (thread_2_full_semaphore_handle<0) 
     return -1; 
    thread_2_mutex_semaphore_handle=createsemaphore(1); 
    if (thread_2_mutex_semaphore_handle<0) 
     return -1; 
    thread_stack=alloc(4096, 0); 
    if (0 >= thread_stack) 
     return -1; 
    if (ALL_OK != createthread(thread_2, thread_stack+4096)) 
     return -1; 
    return 1; 
} 
long read_tread_2() 
{ 
    long value = 0; 

    if (ALL_OK != semaphoredown(thread_2_empty_semaphore_handle)) 
     return -1; 

    if (ALL_OK != semaphoredown(thread_2_mutex_semaphore_handle)) 
     return -1; 

    value = value_thread_2; 
    if(debug == 1) 
     prints("Reading thread 2!\n"); 

    if (ALL_OK != semaphoreup(thread_2_mutex_semaphore_handle)) 
     return -1; 

    if (ALL_OK != semaphoreup(thread_2_full_semaphore_handle)) 
     return -1; 

    return value; 
} 

int send_message(double message) 
{ 
    struct message msg; 

    if(debug == 1) 
     prints("Canculation message"); 
    // We are multiplying the integer with 1000, and thorws all the decimals away 
    long temp = (long)(message * 1000.0); 
    msg.quad_0 = temp; 
    msg.quad_1 = 0; 
    msg.quad_2=0; 
    msg.quad_3=0; 
    msg.quad_4=0; 
    msg.quad_5=0; 
    msg.quad_6=0; 
    msg.quad_7=0; 

    prints("0: "); 
    printhex(msg.quad_0); 
    prints("\n"); 
    prints("1: "); 
    printhex(msg.quad_1); 
    prints("\n"); 

    if (ALL_OK != send(send_port, &msg)) 
     return -1; 
    return 1; 
} 
void administrat_medicin(double amount) 
{ 
} 

void 
    main(int argc, char* argv[]) 
{ 
    debug = 0; 
    long my_pid = getpid(); 

    create_thread_1(); 
    create_thread_2(); 

    /* Launch instances of program_1 */ 
    if (ALL_OK != createprocess(1)) 
    { 
     if(debug == 1) 
      prints("Unable to launch program 1 in a new process\n"); 
     debugger(); 
    } 

    // Finding a send port 
    send_port = findport(0,1); 
    if (send_port < 0) 
    { 
     if(debug == 1) 
      prints("process 1: finding a send port in process 0 failed\n"); 
     terminate(); 
    } 

    /* This is the producer. */ 
    long t1_value; // Puls 
    long t2_value; // Blod sugar 
    double result; 
    double ration = 1.2; 
    while(1) 
    { 
     t1_value = read_tread_1(); 
     if(-1 == t1_value) 
     { 
      if(debug == 1) 
       prints("Error reading t1"); 
      break; 
     } 

     t2_value = read_tread_2(); 
     if(-1 == t2_value) 
     { 
      if(debug == 1) 
       prints("Error reading t2"); 
      break; 
     } 

     // If there are no date yet, no point in sending it 
     // This will also skip if there are no pulse 
     if(t1_value > 0 && t2_value > 0) 
     { 
      // Calculate the medicine to give. 
      prints("Calculating\n"); 
      result = (t2_value * ration); 
      prints("Result: "); 
      printhex(result); 
      prints("\n"); 

      if(debug == 1) 
       prints("Sending message\n"); 
      if(-1 == send_message(result)) 
      { 
       if(debug == 1) 
       prints("Message send failed"); 
      } 
      if(debug == 1) 
       prints("Message sendt"); 
     } 
    } 
} 

만들기 파일 여기

# The following line holds compiler options 
CFLAGS = -fno-exceptions -fno-common -Isrc/include 

# Do not change the following line. You will not be able to compile without it 
PREFIX := "${PWD}/../../support_software/bin/bin" 

bochs_boot: boot/kernel 
    ${PREFIX}/genext2fs -b 1440 -d boot bochs_stuff/b.img 
    (cd bochs_stuff; nice -20 ${PREFIX}/bochs) 

kernel: boot/kernel 

src/include/scwrapper.h: src/include/sysdefines.h 

src/kernel/kernel.h: src/include/sysdefines.h 

boot/kernel: objects/kernel/boot32.o objects/kernel/boot64.o objects/kernel/enter.o src/kernel/kernel_link.ld objects/program_0/executable.o objects/program_1/executable.o objects/program_2/executable.o binary_kernel/binary_kernel.o 
    ${PREFIX}/x86_64-pc-elf-ld --no-warn-mismatch -Tsrc/kernel/binary_kernel_link.ld -o boot/kernel objects/kernel/boot32.o objects/kernel/boot64.o objects/kernel/enter.o binary_kernel/binary_kernel.o objects/program_0/executable.o objects/program_1/executable.o objects/program_2/executable.o 

objects/kernel/boot32.o: src/kernel/boot32.s 
    ${PREFIX}/x86_64-pc-elf-as --32 -o objects/kernel/boot32.o src/kernel/boot32.s 

objects/kernel/boot64.o: src/kernel/boot64.s 
    ${PREFIX}/x86_64-pc-elf-as --64 -o objects/kernel/boot64.o src/kernel/boot64.s 

objects/kernel/enter.o: src/kernel/enter.s 
    ${PREFIX}/x86_64-pc-elf-as --64 -o objects/kernel/enter.o src/kernel/enter.s 

objects/program_startup_code/startup.o: src/program_startup_code/startup.s 
    ${PREFIX}/x86_64-pc-elf-as --64 -o objects/program_startup_code/startup.o src/program_startup_code/startup.s 

objects/program_0/main.o: src/program_0/main.c src/include/scwrapper.h 
    ${PREFIX}/x86_64-pc-elf-gcc -fPIE -m64 $(CFLAGS) -c -O3 -o objects/program_0/main.o src/program_0/main.c 

objects/program_0/executable: objects/program_startup_code/startup.o objects/program_0/main.o 
    ${PREFIX}/x86_64-pc-elf-ld -static -Tsrc/program_startup_code/program_link.ld -o objects/program_0/executable objects/program_startup_code/startup.o objects/program_0/main.o 

objects/program_0/executable.o: objects/program_0/executable 
    ${PREFIX}/x86_64-pc-elf-strip objects/program_0/executable 
    ${PREFIX}/x86_64-pc-elf-objcopy -I binary -O elf32-i386 -B i386 --set-section-flags .data=alloc,contents,load,readonly,data objects/program_0/executable objects/program_0/executable.o 

objects/program_1/main.o: src/program_1/main.c src/include/scwrapper.h 
    ${PREFIX}/x86_64-pc-elf-gcc -fPIE -m64 $(CFLAGS) -c -O3 -o objects/program_1/main.o src/program_1/main.c 

objects/program_1/executable: objects/program_startup_code/startup.o objects/program_1/main.o 
    ${PREFIX}/x86_64-pc-elf-ld -static -Tsrc/program_startup_code/program_link.ld -o objects/program_1/executable objects/program_startup_code/startup.o objects/program_1/main.o 

objects/program_1/executable.o: objects/program_1/executable 
    ${PREFIX}/x86_64-pc-elf-strip objects/program_1/executable 
    ${PREFIX}/x86_64-pc-elf-objcopy -I binary -O elf32-i386 -B i386 --set-section-flags .data=alloc,contents,load,readonly,data objects/program_1/executable objects/program_1/executable.o 

objects/program_2/main.o: src/program_2/main.c src/include/scwrapper.h 
    ${PREFIX}/x86_64-pc-elf-gcc -fPIE -m64 $(CFLAGS) -c -O3 -o objects/program_2/main.o src/program_2/main.c 

objects/program_2/executable: objects/program_startup_code/startup.o objects/program_2/main.o 
    ${PREFIX}/x86_64-pc-elf-ld -static -Tsrc/program_startup_code/program_link.ld -o objects/program_2/executable objects/program_startup_code/startup.o objects/program_2/main.o 

objects/program_2/executable.o: objects/program_2/executable 
    ${PREFIX}/x86_64-pc-elf-strip objects/program_2/executable 
    ${PREFIX}/x86_64-pc-elf-objcopy -I binary -O elf32-i386 -B i386 --set-section-flags .data=alloc,contents,load,readonly,data objects/program_2/executable objects/program_2/executable.o 

clean: 
    -rm -rf objects 
    -rm boot/kernel 
    -rm bochs_stuff/b.img 
    mkdir objects 
    mkdir objects/kernel 
    mkdir objects/program_startup_code 
    mkdir objects/program_0 
    mkdir objects/program_1 
    mkdir objects/program_2 

compile: boot/kernel 

입니다 인쇄 및 printhex 무효

prints(const char* string) 
{ 
/* Loop until we have found the null character. */ 
while(1) 
{ 
    register const char curr = *string++; 

    if (curr) 
    { 
    outb(0xe9, curr); 
    } 
    else 
    { 
    return; 
    } 
} 
} 

void 
printhex(const register long value) 
{ 
const static char hex_helper[16]="abcdef"; 
register int  i; 

/* Print each character of the hexadecimal number. This is a very inefficient 
    way of printing hexadecimal numbers. It is, however, very compact in terms 
    of the number of source code lines. */ 
for(i=15; i>=0; i--) 
{ 
    outb(0xe9, hex_helper[(value>>(i*4))&15]); 
} 
} 

Answer 1

이그나시오 바스케스 - 에이 브람스의 댓글이 뭔가에 부딪쳤을 수 있습니다. 표준 환경이 아니기 때문에 부동 소수점 연산이 지원되는지 알고 있습니까? 그리고 그들이 정말로 필요하거나 권할 만합니까? 당신은 예를 들어 다음 더 중요한 인물이 필요하면

long result;  // integer type 
long t2_value; 

t2_value = 72; 
result = ((t2_value * 10) * 12)/100 ; // result = 86 

:

result = ((t2_value * 100) * 120)/1000 ; // result = 864 

여기

result 현실 세계 단위의 1/1/10의 값입니다 당신은 아마에서 수용 가능한 결과를 얻을 수 있습니다.

Answer 2

여기서 추측 할 위험이 있지만 SSE 지침이 대부분의 커널에서 허용되지 않는다고 확신합니다. (올바르게 기억한다면 설정 옵션이있을 수 있습니다.) 데이터 벡터를 사용하지 않는 경우에도 컴파일러는 종종 SSE 확장을 사용하여 부동 소수점 계산을 수행합니다. -mno-sse (또는 컴파일러에 상응하는 것이 무엇이든)을 Makefile 플래그에 추가하십시오.