I can't spot my mistake...

Okay I've narrowed down the source of my broken math, turns out somehow alu_reg_mov() is not seeing the data:

Code:

make run cd ../ && make --no-print-directory run #MAKECMDGOALS=run cd mak && make -j 1 --no-print-directory -f main.mak run PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/test_alu.o -c ../tests/test_alu.c cc -D NDEBUG -fPIE -L ../lib -o ../bin/test_alu.AppImage ../tests/test_alu.o -Wl,-rpath,../lib -l alu ../bin/test_alu.AppImage ../tests/test_alu.c:921: main() Pre-allocating 64 ALU registers... ../tests/test_alu.c:371: bitwise() 'Checking Bitwise Operations...' ../tests/test_alu.c:372: bitwise() '===========================================' ../src/alu_math.c:316: mov() src = 0000000000000000000000000000000011011110101011011100000011011110 ../src/alu_math.c:324: mov() s = 0, ptr = 0x55f812973320, mask = 0000000000000001, pos = 0, seg = 0, bit = 0 ../src/alu_math.c:327: mov() d = 0, ptr = 0x55f812973320, mask = 0000000000000001, pos = 0, seg = 0, bit = 0 ../src/alu_math.c:324: mov() s = 0, ptr = 0x55f812973320, mask = 0000000000000002, pos = 1, seg = 0, bit = 1 ../src/alu_math.c:327: mov() d = 0, ptr = 0x55f812973320, mask = 0000000000000002, pos = 1, seg = 0, bit = 1 ../src/alu_math.c:324: mov() s = 0, ptr = 0x55f812973320, mask = 0000000000000004, pos = 2, seg = 0, bit = 2 ../src/alu_math.c:327: mov() d = 0, ptr = 0x55f812973320, mask = 0000000000000004, pos = 2, seg = 0, bit = 2 ../src/alu_math.c:324: mov() s = 0, ptr = 0x55f812973320, mask = 0000000000000008, pos = 3, seg = 0, bit = 3 ../src/alu_math.c:327: mov() d = 0, ptr = 0x55f812973320, mask = 0000000000000008, pos = 3, seg = 0, bit = 3 ... ../tests/test_alu.c:640: uint_print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:858: print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:964: main() Error 0xFFFFFFFF -1 'Unknown error -1' make[2]: *** [main.mak:95: test] Error 1 make[1]: *** [makefile:10: run] Error 2 make: *** [makefile:4: run] Error 2 Compilation failed.

From this function:

Code:

int alu_reg_mov( alu_t *alu, alu_reg_t dst, alu_reg_t src ) { int ret; void *D, *S; alu_bit_t d, s; size_t ndiff, vdiff, upto; bool neg, NaN = false; alu_reg_t DEXP, DMAN, SEXP, SMAN; ret = alu_reg_clr( alu, dst ); if ( ret == 0 ) { dst.node %= alu_used( alu ); src.node %= alu_used( alu ); D = alu_reg_data( alu, dst ); S = alu_reg_data( alu, dst ); /* Check for +/- */ neg = alu_reg_below0( alu, src ); if ( alu_reg_floating( src ) ) { ... return ENOSYS; } ndiff = dst.upto - dst.from; vdiff = src.upto - src.from; alu_print_reg( __FILE__ ":" INT2STR(__LINE__) ": mov() src", alu, src, 0, 1 ); d = alu_bit_set_bit( D, dst.from ); s = alu_bit_set_bit( S, src.from ); upto = dst.from + LOWEST( ndiff, vdiff ); for ( ; d.bit < upto; alu_bit_inc(&d), alu_bit_inc(&s) ) { alu_print_bit( __FILE__ ":" INT2STR(__LINE__) ": mov() s", s, 1 ); *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( *(s.ptr) & s.mask, s.mask ); alu_print_bit( __FILE__ ":" INT2STR(__LINE__) ": mov() d", d, 1 ); } for ( ; d.bit < dst.upto; alu_bit_inc(&d) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( neg, d.mask ); } alu_print_reg( __FILE__ ":" INT2STR(__LINE__) ": mov() dst", alu, dst, 0, 1 ); return 0; } alu_error( ret ); return ret; }

Any ideas?

Edit: Just spotted that I had accidentally used dst for setting the pointer to the 1st segment of src register, rectifying that resolved my problem and all the math started behaving as expected

Ok, now that all those bugs have been sorted I've gone back to the alu_reg_mov() function to do more of the float to integer step (also rectified a few bugs I noticed there), I've dealt with the conversion of +/- Infinity to min/max of the integer, even dealt with the out of bounds exponent to 0/max, now I just need to do the final stretch, gonna take a break while I do some stuff for a neighbor (old guy who's not able to walk much anymore), in the mean time I'd like anyone interest in doing so to have a look at the function and tell me any problems they see or give any suggestions they have, (I will also be learning how to use check as laserlight keeps telling me to (although she didn't specifically mention a suite but check seems like it will be easier to learn) when I get back to coding later so you'll have plenty of time to do so before I go back to the function)

Edit: Whoops forgot to actually paste the function in:

Code:

int alu_reg_mov( alu_t *alu, alu_reg_t dst, alu_reg_t src ) { int ret; void *D, *S; alu_bit_t d, s; size_t ndiff, vdiff, upto; bool neg, NaN = false, Inf = false; alu_reg_t DEXP, DMAN, SEXP, SMAN; ret = alu_reg_clr( alu, dst ); if ( ret == 0 ) { dst.node %= alu_used( alu ); src.node %= alu_used( alu ); D = alu_reg_data( alu, dst ); S = alu_reg_data( alu, src ); /* Check for +/- */ neg = alu_reg_below0( alu, src ); if ( alu_reg_floating( src ) ) { alu_reg_init( alu, SEXP, src.node, 0 ); alu_reg_init( alu, SMAN, src.node, 0 ); SEXP.upto = src.upto - 1; SEXP.from = src.from + src.mant; SMAN.upto = src.from + src.mant; SMAN.from = src.from; /* Check if should set NaN or Infinity */ DEXP.upto = SEXP.upto; DEXP.from = SEXP.from; alu_reg_set_max( alu, DEXP ); Inf = (alu_reg_cmp( alu, SEXP, DEXP ) == 0); if ( alu_reg_floating( dst ) ) { alu_reg_init( alu, DEXP, dst.node, 0 ); DEXP.upto = dst.upto - 1; DEXP.from = dst.from + dst.mant; DMAN.upto = dst.from + dst.mant; DMAN.from = dst.from; /* Set +/- */ d = alu_bit_set_bit( D, DEXP.upto ); *(d.ptr) &= ~(d.mask); *(d.ptr) |= (neg * d.mask); /* Simplify code and pass on duties to another instance, added * bonus of setting Infinity if >= Exponent limit */ alu_reg_mov( alu, DEXP, SEXP ); ndiff = DMAN.upto - DMAN.from; vdiff = SMAN.upto - SMAN.from; /* Make sure we copy the upper bits of the src mantissa */ SMAN.from = SMAN.upto - LOWEST( ndiff, vdiff ); /* Whether it is NaN or a fittable number copying the mantissa * is fine as long as we make sure it was not Infinity to begin * with */ return Inf ? alu_reg_clr( alu, DMAN ) : alu_reg_mov( alu, DMAN, SMAN ); } else if ( Inf ) { /* Infinity is not something an integer can hold, default to * max of the integer, if -Infinity the not operation will flip * to min of the integer */ (void)alu_reg_set_max( alu, dst ); return neg ? alu_reg_not( alu, dst ) : 0; } /* Mantissa is always bigger than exponent so it is safe to use * as the temporary copy of number to shift */ alu_reg__shr( alu, DEXP, DMAN, 1 ); /* Check if exponent is negative - meaning the number is between * 0 & 1, if it is then just set the integer to 0 */ ret = alu_reg_cmp( alu, SEXP, DEXP ); if ( ret < 0 ) return alu_reg_clr( alu, dst ); DEXP.from = dst.from; DEXP.upto = dst.upto; ndiff = dst.upto - dst.from; alu_reg_set_raw( alu, DEXP, &(ndiff), sizeof(size_t), 0 ); ret = alu_reg_cmp( alu, DEXP, SEXP ); /* Check if number is to big to fit in integer */ if ( ret >= 0 ) return alu_reg_set_max( alu, dst ); // FIXME: Finish implementing moving alu_fpn_t to alu_int_t/alu_uint_t // if ( alu_reg_cmp( alu, EXP, BIAS ) >= 0 ) return ENOSYS; } ndiff = dst.upto - dst.from; vdiff = src.upto - src.from; d = alu_bit_set_bit( D, dst.from ); s = alu_bit_set_bit( S, src.from ); upto = dst.from + LOWEST( ndiff, vdiff ); for ( ; d.bit < upto; alu_bit_inc(&d), alu_bit_inc(&s) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( *(s.ptr) & s.mask, s.mask ); } for ( ; d.bit < dst.upto; alu_bit_inc(&d) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( neg, d.mask ); } return 0; } alu_error( ret ); return ret; }

Just to be sure, laserlight is this what you meant?
alu/check_alu.c at master * awsdert/alu * GitHub

Getting a strange difference in behavior when I run 'make check' vs 'make check run', 'make check' gives me expected behavior but the other when ends in a fault at division despite using the same code and values:

Code:

make check (in directory: /mnt/MEDIA/HOME/github/alu/tests) cd ../ && make --no-print-directory check #MAKECMDGOALS=check cd mak && make -j 1 --no-print-directory -f main.mak check PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=check_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c ../src/alu_math.c: In function ‘alu_reg_mov’: ../src/alu_math.c:235:12: warning: unused variable ‘NaN’ [-Wunused-variable] 235 | bool neg, NaN = false, Inf = false; | ^~~ cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu.o -c ../tests/check_alu.c cc -D NDEBUG -fPIE -L ../lib -o ../bin/check_alu.AppImage ../tests/check_alu.o -Wl,-rpath,../lib -l alu -l check ../bin/check_alu.AppImage Running unit tests under 'check' test suite Running suite(s): Money Initialising ALU Getting registers 100%: Checks: 1, Failures: 0, Errors: 0 rm ../src/alu_math.o ../src/alu_main.o ../src/alu_uint.o ../src/alu_mem.o ../src/alu_int.o ../src/alu_bit.o ../src/alu_vec.o ../src/alu_fpn.o ../tests/check_alu.o Compilation finished successfully.

Code:

make check run (in directory: cd ../ && make --no-print-directory check run #MAKECMDGOALS=check run cd mak && make -j 1 --no-print-directory -f main.mak check run PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=check_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c ../src/alu_math.c: In function ‘alu_reg_mov’: ../src/alu_math.c:235:12: warning: unused variable ‘NaN’ [-Wunused-variable] 235 | bool neg, NaN = false, Inf = false; | ^~~ cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu.o -c ../tests/check_alu.c cc -D NDEBUG -fPIE -L ../lib -o ../bin/check_alu.AppImage ../tests/check_alu.o -Wl,-rpath,../lib -l alu -l check ../bin/check_alu.AppImage Running unit tests under 'check' test suite Running suite(s): Money Initialising ALU Getting registers 100%: Checks: 1, Failures: 0, Errors: 0 make[2]: Nothing to be done for 'run'. rm ../src/alu_math.o ../src/alu_main.o ../src/alu_uint.o ../src/alu_mem.o ../src/alu_int.o ../src/alu_bit.o ../src/alu_vec.o ../src/alu_fpn.o ../tests/check_alu.o #MAKECMDGOALS=check run cd mak && make -j 1 --no-print-directory -f main.mak check run PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=check_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c ../src/alu_math.c: In function ‘alu_reg_mov’: ../src/alu_math.c:235:12: warning: unused variable ‘NaN’ [-Wunused-variable] 235 | bool neg, NaN = false, Inf = false; | ^~~ cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu.o -c ../tests/check_alu.c cc -D NDEBUG -fPIE -L ../lib -o ../bin/check_alu.AppImage ../tests/check_alu.o -Wl,-rpath,../lib -l alu -l check ../bin/check_alu.AppImage Running unit tests under 'check' test suite Running suite(s): Money 0%: Checks: 1, Failures: 1, Errors: 0 ../tests/check_alu.c:121:F:Core:test_alu_create:0: Expected 3, Got 0 make[2]: *** [main.mak:99: check] Error 1 rm ../src/alu_math.o ../src/alu_main.o ../src/alu_uint.o ../src/alu_mem.o ../src/alu_int.o ../src/alu_bit.o ../src/alu_vec.o ../src/alu_fpn.o ../tests/check_alu.o make[1]: *** [makefile:10: run] Error 2 make: *** [makefile:4: check] Error 2 Compilation failed.

Someone see what I don't see? (as usual the code is uploaded to github, link in my signature)

I was going to look, but I can't get that far...

Code:

$ git pull Already up to date. $ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from ../include/alu.h:4:0, from ../src/alu_vec.c:1: ../cloned/unic/include/unic/limits.h:137:0: warning: "CHAR_UNSIGNED" redefined # define CHAR_UNSIGNED UNIC_CHAR_UNSIGNED ../cloned/unic/include/unic/limits.h:132:0: note: this is the location of the previous definition # define CHAR_UNSIGNED 0 In file included from ../include/alu.h:5:0, from ../src/alu_vec.c:1: ../cloned/unic/include/unic/stdint.h:337:9: error: unknown type name ‘unic_ptrdiff_t’ typedef unic_ptrdiff_t ptrdiff_t; ^~~~~~~~~~~~~~ ../cloned/unic/include/unic/stdint.h:337:24: error: conflicting types for ‘ptrdiff_t’ typedef unic_ptrdiff_t ptrdiff_t; ^~~~~~~~~ In file included from ../cloned/unic/include/unic/stdint.h:14:0, from ../include/alu.h:5, from ../src/alu_vec.c:1: /usr/lib/gcc/x86_64-linux-gnu/7/include/stddef.h:149:26: note: previous declaration of ‘ptrdiff_t’ was here typedef __PTRDIFF_TYPE__ ptrdiff_t; ^~~~~~~~~ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

Quote:

Originally Posted by hamster_nz

I was going to look, but I can't get that far...

Code:

$ git pull Already up to date. $ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git config pull.rebase false && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from ../include/alu.h:4:0, from ../src/alu_vec.c:1: ../cloned/unic/include/unic/limits.h:137:0: warning: "CHAR_UNSIGNED" redefined # define CHAR_UNSIGNED UNIC_CHAR_UNSIGNED ../cloned/unic/include/unic/limits.h:132:0: note: this is the location of the previous definition # define CHAR_UNSIGNED 0 In file included from ../include/alu.h:5:0, from ../src/alu_vec.c:1: ../cloned/unic/include/unic/stdint.h:337:9: error: unknown type name ‘unic_ptrdiff_t’ typedef unic_ptrdiff_t ptrdiff_t; ^~~~~~~~~~~~~~ ../cloned/unic/include/unic/stdint.h:337:24: error: conflicting types for ‘ptrdiff_t’ typedef unic_ptrdiff_t ptrdiff_t; ^~~~~~~~~ In file included from ../cloned/unic/include/unic/stdint.h:14:0, from ../include/alu.h:5, from ../src/alu_vec.c:1: /usr/lib/gcc/x86_64-linux-gnu/7/include/stddef.h:149:26: note: previous declaration of ‘ptrdiff_t’ was here typedef __PTRDIFF_TYPE__ ptrdiff_t; ^~~~~~~~~ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

It seems your copy of unic is out of date which means my code for auto-updating that in the makefile is faulty, I'm gonna take a look at that but for now try deleting unic from your directory and let it get re-downloaded

Seemed to have resolved it, seems the cause was a left over hack, removed it now

Turned out I hadn't resolved it, still getting errors, decided to step up my checks into loops iterating through the bit count of a segment, ended up with an error earlier in the tests, but this error is strange:

Code:

../tests/check_alu.c:227:F:Core:test_alu_create:0: Line 359, 64 >> 32 = 64, Got 0

Code:

int test__alu_uint_shift ( size_t line , alu_t* alu , uint_t num , uint_t val , char *op , uintmax_t expect , func_alu_reg__shift_t _shift , func_alu_reg_shift_t shift ) { int ret; alu_reg_t NUM, VAL; void *data; alu_reg_init( alu, NUM, num, 0 ); ck_assert( NUM.node == num ); ck_assert( NUM.upto == alu_bits_perN(alu) ); ck_assert( NUM.from == 0 ); ck_assert( NUM.mant == 0 ); ck_assert( NUM.info == 0 ); alu_reg_init( alu, VAL, val, 0 ); ck_assert( VAL.node == val ); ck_assert( VAL.upto == alu_bits_perN(alu) ); ck_assert( VAL.from == 0 ); ck_assert( VAL.mant == 0 ); ck_assert( VAL.info == 0 ); NUM.upto = bitsof(uintmax_t); VAL.upto = bitsof(uintmax_t); ret = shift( alu, NUM, VAL, _shift ); if ( ret == 0 ) { data = alu_data( alu, num ); ck_assert_msg ( memcmp( data, &expect, sizeof(uintmax_t) ) == 0 , "Line %zu, %s = %ju, Got %ju" , line , op , expect , *((uintmax_t*)data) ); return 0; } alu_error(ret); return ret; } #define test_alu_uint_shift( alu, num, val, op, expect, _shift, shift ) \ test__alu_uint_shift( __LINE__, alu, num, val, op, (expect), _shift, shift ) ... for ( i = 0; i < bitsof(uintmax_t); ++i ) { sprintf( stdstr, "%u >> %u", want, i ); test_alu_uint_set_raw( __LINE__, alu, val, i ); test_alu_uint_set_raw( __LINE__, alu, num, want ); test_alu_uint_shift ( alu , num , val , stdstr , want >> i , alu_reg__shr , alu_reg__shift ); }

Anyone able to explain to me how the hardwired shift can end up with an incorrect result? btw both want and i are unsigned int

A clean clone still doesn't work for me:

Code:

$ git clone GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs Cloning into 'alu'... remote: Enumerating objects: 396, done. remote: Counting objects: 100% (396/396), done. remote: Compressing objects: 100% (377/377), done. remote: Total 396 (delta 277), reused 126 (delta 15), pack-reused 0 Receiving objects: 100% (396/396), 138.31 KiB | 362.00 KiB/s, done. Resolving deltas: 100% (277/277), done. $ cd alu/ $ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Cloning into 'unic'... remote: Enumerating objects: 193, done. remote: Counting objects: 100% (193/193), done. remote: Compressing objects: 100% (157/157), done. remote: Total 193 (delta 105), reused 112 (delta 26), pack-reused 0 Receiving objects: 100% (193/193), 60.84 KiB | 293.00 KiB/s, done. Resolving deltas: 100% (105/105), done. Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so mkdir ../bin mkdir ../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from /usr/include/stdio.h:41:0, from ../include/alu.h:11, from ../src/alu_vec.c:1: /usr/include/x86_64-linux-gnu/bits/libio.h:466:58: error: expected declaration specifiers or ‘...’ before ‘)’ token extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t); ^ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

But I can get it to build with:

Code:

gcc -o alu *.c ../tests/test_alu.c -I ../include -I ../cloned/unic/include -Wall -pedantic -O4

Will take a look

Code:

../tests/test_alu.c:199: modify() 0x00000000DEADC0DE / 0x0000000000000BAD, Expected 0x0000000000131264, Got 0x0000000000098932, op = '/'

I guess you already know that 98932 (the answer you get) is half 131264 (the answer you expect)

Here's a bit of a bug in your division code:

Code:

if ( ret == 0 ) { (void)alu_reg_clr( alu, num ); <<<< A num.node %= alu_used( alu ); val.node %= alu_used( alu ); rem.node %= alu_used( alu ); tmp.node %= alu_used( alu ); nNeg = alu_reg_below0( alu, num ); <<< B vNeg = alu_reg_below0( alu, val );

Note how you clear 'num' with "alu_reg_clr( alu, num )" and the you test to see if num is below zero. It will always be zero.

Instead you want to clear out num after you have checked if it is below zero:

Code:

if ( ret == 0 ) { num.node %= alu_used( alu ); val.node %= alu_used( alu ); rem.node %= alu_used( alu ); tmp.node %= alu_used( alu ); nNeg = alu_reg_below0( alu, num ); vNeg = alu_reg_below0( alu, val ); (void)alu_reg_clr( alu, num ); <<<< THIS CHANGE

I also think that

Code:

if ( vNeg ) alu_reg_neg( alu, val );

might need to be

Code:

if ( nNeg ^ nNeg) alu_reg_neg( alu, val );

[code]

As a negative number divided by a negative number is a positive result.

Also in alu_math.h

Code:

int_t alu_reg_not( alu_t *alu, alu_reg_t num ) { alu_bit_t n, e; void *part; size_t i, stop, mask, mask_init, mask_last; if ( alu ) { num.node %= alu_used( alu ); part = alu_reg_data( alu, num ); n = alu_bit_set_bit( part, num.from ); e = alu_bit_set_bit( part, num.upto - 1 ); mask = 0; mask = mask_init = mask_last = ~mask; mask_init <<= n.pos; mask_last <<= (bitsof(uintmax_t) - e.pos) - 1; stop = e.seg - n.seg; *(n.ptr) ^= SET2IF( stop, mask_init, mask_init & mask_last ); for ( i = 1; i < stop; ++i ) n.ptr[i] = ~(n.ptr[i]); *(e.ptr) ^= SET1IF( stop, mask_last ); return 0; } return alu_err_null_ptr( "alu" ); }

it works on the following process..

- flip bits up to the next word boundary.
- flip words while we still can flip a full word's worth of bits.
- flip the remaining bits in the last work.

I'm not sure this will work if you are only flipping a few bits - it needs to span at least one word boundary. It doesn't seem intuitively right - you might want to look at it more closely.

Wow, either you burning the midnight oil or we live in vastly different timezones, GMT+0 (London) here, anyways I'll start with this post

Quote:

Originally Posted by hamster_nz

Here's a bit of a bug in your division code:

Code:

if ( ret == 0 ) { (void)alu_reg_clr( alu, num ); <<<< A num.node %= alu_used( alu ); val.node %= alu_used( alu ); rem.node %= alu_used( alu ); tmp.node %= alu_used( alu ); nNeg = alu_reg_below0( alu, num ); <<< B vNeg = alu_reg_below0( alu, val );

Note how you clear 'num' with "alu_reg_clr( alu, num )" and the you test to see if num is below zero. It will always be zero.

Instead you want to clear out num after you have checked if it is below zero:

Code:

if ( ret == 0 ) { num.node %= alu_used( alu ); val.node %= alu_used( alu ); rem.node %= alu_used( alu ); tmp.node %= alu_used( alu ); nNeg = alu_reg_below0( alu, num ); vNeg = alu_reg_below0( alu, val ); (void)alu_reg_clr( alu, num ); <<<< THIS CHANGE

Nice catch, it also means there's another bug in which rem receives negative numbers, so I'll fix that before I try to respond to any more posts

Quote:

Originally Posted by hamster_nz

I also think that

Code:

if ( vNeg ) alu_reg_neg( alu, val );

might need to be

Code:

if ( nNeg ^ nNeg) alu_reg_neg( alu, val );

[code]

As a negative number divided by a negative number is a positive result.

In this case you're wrong, val is number being divide by, I only flip it to positive to make division behave correctly, I flip it back after so that it is left the same as we got it, num is where that rule you stated applies

Edit: done

Quote:

Originally Posted by hamster_nz

Also in alu_math.h

Code:

int_t alu_reg_not( alu_t *alu, alu_reg_t num ) { alu_bit_t n, e; void *part; size_t i, stop, mask, mask_init, mask_last; if ( alu ) { num.node %= alu_used( alu ); part = alu_reg_data( alu, num ); n = alu_bit_set_bit( part, num.from ); e = alu_bit_set_bit( part, num.upto - 1 ); mask = 0; mask = mask_init = mask_last = ~mask; mask_init <<= n.pos; mask_last <<= (bitsof(uintmax_t) - e.pos) - 1; stop = e.seg - n.seg; *(n.ptr) ^= SET2IF( stop, mask_init, mask_init & mask_last ); for ( i = 1; i < stop; ++i ) n.ptr[i] = ~(n.ptr[i]); *(e.ptr) ^= SET1IF( stop, mask_last ); return 0; } return alu_err_null_ptr( "alu" ); }

it works on the following process..

- flip bits up to the next word boundary.
- flip words while we still can flip a full word's worth of bits.
- flip the remaining bits in the last work.

I'm not sure this will work if you are only flipping a few bits - it needs to span at least one word boundary. It doesn't seem intuitively right - you might want to look at it more closely.

I added that to the tests but I've seen no failures in it despite the test iterating through every bit each segment would have, however I have just noticed a subtle bug there so I will rectify that now

Edit: Forgot to pay attention to the macro, there was no subtle bug

Quote:

Originally Posted by hamster_nz

A clean clone still doesn't work for me:

Code:

$ git clone GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs Cloning into 'alu'... remote: Enumerating objects: 396, done. remote: Counting objects: 100% (396/396), done. remote: Compressing objects: 100% (377/377), done. remote: Total 396 (delta 277), reused 126 (delta 15), pack-reused 0 Receiving objects: 100% (396/396), 138.31 KiB | 362.00 KiB/s, done. Resolving deltas: 100% (277/277), done. $ cd alu/ $ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Cloning into 'unic'... remote: Enumerating objects: 193, done. remote: Counting objects: 100% (193/193), done. remote: Compressing objects: 100% (157/157), done. remote: Total 193 (delta 105), reused 112 (delta 26), pack-reused 0 Receiving objects: 100% (193/193), 60.84 KiB | 293.00 KiB/s, done. Resolving deltas: 100% (105/105), done. Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so mkdir ../bin mkdir ../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from /usr/include/stdio.h:41:0, from ../include/alu.h:11, from ../src/alu_vec.c:1: /usr/include/x86_64-linux-gnu/bits/libio.h:466:58: error: expected declaration specifiers or ‘...’ before ‘)’ token extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t); ^ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

That... I honestly have no idea why it is happening, at 1st I though it was a missing #endif but then that would cause my compiles to fail as well, it would even cause that different compile command you gave to fail, only thing I think of is maybe the order of the flags?

My updated output:

Code:

../tests/test_alu.c:921: main() Pre-allocating 64 ALU registers... ../tests/test_alu.c:371: bitwise() 'Checking Bitwise Operations...' ../tests/test_alu.c:372: bitwise() '===========================================' ../tests/test_alu.c:388: bitwise() 'Shifting values...' ../tests/test_alu.c:389: bitwise() '===========================================' ../tests/test_alu.c:405: bitwise() 'Rotating values...' ../tests/test_alu.c:406: bitwise() '===========================================' ../tests/test_alu.c:431: mathmatical() 'Checking Mathematic Operations...' ../tests/test_alu.c:432: mathmatical() '===========================================' ../tests/test_alu.c:812: print_value() 'Printing values...' ../tests/test_alu.c:813: print_value() '===========================================' ../tests/test_alu.c:566: reg_print_value() 'Testing alu_lit2reg() & alu_reg2str()' ../tests/test_alu.c:567: reg_print_value() '-------------------------------------' ../tests/test_alu.c:603: reg_print_value() Expected = '123', Got = '123' ../tests/test_alu.c:626: uint_print_value() 'Testing alu_str2uint() & alu_uint2str()' ../tests/test_alu.c:627: uint_print_value() '---------------------------------------' ../tests/test_alu.c:640: uint_print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:858: print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:964: main() Error 0xFFFFFFFF -1 'Unknown error -1'

Fixes - after the loop in the divide function, you need to shift any leftover bits:

Code:

alu_reg__shl( alu, num, tmp, bits ); *(n.ptr) |= n.mask; bits = 0; } } + if(bits != 0) + alu_reg__shl( alu, num, tmp, bits ); if ( seg.from > rem.from ) alu_reg__shl( alu, num, tmp, bits );

Fix for the sign being wrong on the result of division:

Code:

if ( nNeg ) alu_reg_neg( alu, rem ); + if ( vNeg ^ nNeg) alu_reg_neg( alu, val ); return ret;

in alu_reg_rem, the wrong thing is moved into the result:

Code:

alu_reg_init( alu, REM, nodes[0], 0 ); alu_reg_init( alu, TMP, nodes[1], 0 ); ret = alu_reg_divide( alu, NUM, VAL, REM, TMP ); + (void)alu_reg_mov( alu, NUM, REM ); alu_rem_reg_nodes( alu, nodes, 2 ); return ret; }

Oh, I'm in GMT+12... so we are 12 hours apart...

Quote:

Originally Posted by hamster_nz

My updated output:

Code:

../tests/test_alu.c:921: main() Pre-allocating 64 ALU registers... ../tests/test_alu.c:371: bitwise() 'Checking Bitwise Operations...' ../tests/test_alu.c:372: bitwise() '===========================================' ../tests/test_alu.c:388: bitwise() 'Shifting values...' ../tests/test_alu.c:389: bitwise() '===========================================' ../tests/test_alu.c:405: bitwise() 'Rotating values...' ../tests/test_alu.c:406: bitwise() '===========================================' ../tests/test_alu.c:431: mathmatical() 'Checking Mathematic Operations...' ../tests/test_alu.c:432: mathmatical() '===========================================' ../tests/test_alu.c:812: print_value() 'Printing values...' ../tests/test_alu.c:813: print_value() '===========================================' ../tests/test_alu.c:566: reg_print_value() 'Testing alu_lit2reg() & alu_reg2str()' ../tests/test_alu.c:567: reg_print_value() '-------------------------------------' ../tests/test_alu.c:603: reg_print_value() Expected = '123', Got = '123' ../tests/test_alu.c:626: uint_print_value() 'Testing alu_str2uint() & alu_uint2str()' ../tests/test_alu.c:627: uint_print_value() '---------------------------------------' ../tests/test_alu.c:640: uint_print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:858: print_value() Error 0xFFFFFFFF -1 'Unknown error -1' ../tests/test_alu.c:964: main() Error 0xFFFFFFFF -1 'Unknown error -1'

Fixes - after the loop in the divide function, you need to shift any leftover bits:

Code:

alu_reg__shl( alu, num, tmp, bits ); *(n.ptr) |= n.mask; bits = 0; } } + if(bits != 0) + alu_reg__shl( alu, num, tmp, bits ); if ( seg.from > rem.from ) alu_reg__shl( alu, num, tmp, bits );

Fix for the sign being wrong on the result of division:

Code:

if ( nNeg ) alu_reg_neg( alu, rem ); + if ( vNeg ^ nNeg) alu_reg_neg( alu, val ); return ret;

in alu_reg_rem, the wrong thing is moved into the result:

Code:

alu_reg_init( alu, REM, nodes[0], 0 ); alu_reg_init( alu, TMP, nodes[1], 0 ); ret = alu_reg_divide( alu, NUM, VAL, REM, TMP ); + (void)alu_reg_mov( alu, NUM, REM ); alu_rem_reg_nodes( alu, nodes, 2 ); return ret; }

Oh, I'm in GMT+12... so we are 12 hours apart...

Ah so that'll be why we end up with lot's a posts before we get communication, btw again you're assuming val is the result, val is NOT the result, num is the result, switched out my seg.from > rem.from for bits but I'm not adding another if statement for the same task like you did. Nice catch on the alu_reg_rem() bug, anyways I'm currently hitting a strange bug with alu_reg__shift() in that somehow during the retrieval of VAL into by the value of VAL is filled into NUM

Code:

int_t alu_reg__shift ( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , alu_reg_t TMP , func_alu_reg__shift_t _shift ) { int ret, cmp; uintmax_t by; if ( alu ) { by = NUM.upto - NUM.from; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); TMP.node %= alu_used( alu ); alu_uint_set_raw( alu, TMP.node, by ); cmp = alu_reg_cmp( alu, VAL, TMP ); if ( cmp < 0 ) { alu_print_reg( "NUM#1", alu, NUM, 0, 1 ); alu_print_reg( "VAL#1", alu, VAL, 0, 1 ); alu_uint_get_raw( alu, VAL.node, &by ); alu_print_reg( "NUM#2", alu, NUM, 0, 1 ); ret = _shift( alu, NUM, TMP, by ); } else { ret = _shift( alu, NUM, TMP, -1 ); } return ret; } return alu_err_null_ptr("alu"); }

Tried following the call chain of alu_uint_get_raw() but didn't spot anything that would cause the node of VAL to suddenly change to NUM's node

Edit: Found out that somehow tmp in alu_reg_get_raw() gets the same node index as NUM.node of alu_reg__shift(), not been able to identify why, nor why it only shows up in test_alu.c and not check_alu.c
Edit: Gotta go to work, assuming you respond in your morning I'll probably be responding in my morning rather than my tonight

Found the source of the error, seems when I added a node in modify() for TMP I forgot to tell alu_get_reg_nodes() the new array size so TMP was initiated with the value 0, rectified along with a bug I spotted while hunting for the problem

Gonna go to bed, thought I'd post my current problem to see if any suggestions or fixes are posted by the time I get up in the morning. All math functions seem to be working fine, added some checks for node value of 0 to prevent corruption of active nodes flags, the current problem however is converting plain integers to string, here's the relevant output:

Code:

make check cd ../ && make --no-print-directory check #MAKECMDGOALS=check cd mak && make -j 1 --no-print-directory -f main.mak check PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=check_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu.o -c ../tests/check_alu.c cc -D NDEBUG -fPIE -L ../lib -o ../bin/check_alu.AppImage ../tests/check_alu.o -Wl,-rpath,../lib -l alu -l check ../bin/check_alu.AppImage Running unit tests under 'check' test suite Running suite(s): ALU ../tests/check_alu.c:12: wrChar() wrChar('3',0x7ffd2e28dd70) ../tests/check_alu.c:12: wrChar() wrChar('6',0x7ffd2e28dd70) ../tests/check_alu.c:30: flip() alustr = '6', taken = 1 0%: Checks: 1, Failures: 1, Errors: 0 ../tests/check_alu.c:534:F:Core:test_alu_create:0: Expected '64', Got '6' rm ../src/alu_math.o ../src/alu_main.o ../src/alu_uint.o ../src/alu_mem.o ../src/alu_int.o ../src/alu_bit.o ../src/alu_vec.o ../src/alu_fpn.o ../tests/check_alu.o make[2]: *** [main.mak:99: check] Error 1 make[1]: *** [makefile:10: check] Error 2 make: *** [makefile:4: check] Error 2 Compilation failed.

And here's the function:

Code:

int_t alu_reg2str( alu_t *alu, alu_dst_t dst, alu_reg_t src, alu_base_t base ) { alu_reg_t NUM, VAL, REM, TMP; int ret; size_t digit = 0, b; uint_t nodes[ALU_BASE_COUNT] = {0}; bool neg; char *base_str = base.lowercase ? ALU_BASE_STR_0toztoZ : ALU_BASE_STR_0toZtoz; src.upto = LOWEST( alu_bits_perN( alu ), src.upto ); if ( !(dst.next) || !(dst.flip) ) { ret = EADDRNOTAVAIL; alu_error(ret); return ret; } if ( !base.base ) base.base = 10; if ( base.base > strlen(base_str) ) { ret = ERANGE; alu_error(ret); return ret; } ret = alu_get_reg_nodes( alu, nodes, ALU_BASE_COUNT, 0 ); if ( ret != 0 ) { alu_error( ret ); return ret; } alu_reg_init( alu, NUM, nodes[ALU_BASE_NUM], 0 ); alu_reg_init( alu, VAL, nodes[ALU_BASE_VAL], 0 ); alu_reg_init( alu, REM, nodes[ALU_BASE_REM], 0 ); alu_reg_init( alu, TMP, nodes[ALU_BASE_TMP], 0 ); neg = alu_reg_below0( alu, src ); alu_reg_mov( alu, NUM, src ); alu_set_raw( alu, VAL.node, base.base, 0 ); if ( neg ) (void)alu_reg_neg( alu, NUM ); while ( alu_reg_cmp( alu, NUM, VAL ) >= 0 ) { ret = alu_reg_divide( alu, NUM, VAL, REM, TMP ); if ( ret == ENODATA ) { alu_error( ret ); goto fail; } if ( digit == 3 ) { switch ( base.digsep ) { case '\'': case '_': case ',': ret = dst.next( base.digsep, dst.dst ); if ( ret != 0 ) goto fail; } digit = 0; } alu_reg_get_raw( alu, TMP, &b, sizeof(size_t) ); ret = dst.next( base_str[b], dst.dst ); if ( ret != 0 ) { alu_error(ret); goto fail; } ++digit; } alu_reg_get_raw( alu, NUM, &b, sizeof(size_t) ); ret = dst.next( base_str[b], dst.dst ); if ( ret != 0 ) { alu_error(ret); goto fail; } dst.flip( dst.dst ); fail: alu_rem_reg_nodes( alu, nodes, ALU_BASE_COUNT ); return ret; }

If I get lucky and someone spotted the source of the bug by morning, that's great, if not then too bad but no biggy, not particularly banking on it to begin with. And with that, good night all :)

Welp, resolved that error just now, I don't have any serious ideas regarding hamster_nz's compile issues so I'll leave that on the back burner, time to go back to alu_reg_mov() and finish the float to integer and vise versa stuff

Gonna get ready for work then start working on integer to float conversion, in the meantime if anyone feels like looking for bugs in my float to integer conversion, here's the function:

Code:

int alu_reg_mov ( alu_t *alu, alu_reg_t DST, alu_reg_t SRC ) { int ret; void *D, *S; uint_t tmp = 0; alu_bit_t d, s; size_t ndiff, vdiff, upto, exp, bias; bool neg, Inf = false; alu_reg_t DEXP, DMAN, SEXP, SMAN, TMP; ret = alu_reg_clr( alu, DST ); if ( ret == 0 ) { DST.node %= alu_used( alu ); SRC.node %= alu_used( alu ); /* Check for +/- */ neg = alu_reg_below0( alu, SRC ); if ( alu_reg_floating( SRC ) ) { alu_reg_init( alu, SEXP, SRC.node, 0 ); alu_reg_init( alu, SMAN, SRC.node, 0 ); SEXP.upto = SRC.upto - 1; SEXP.from = SRC.from + SRC.mant; SMAN.upto = SRC.from + SRC.mant; SMAN.from = SRC.from; bias = -1; bias <<= (SEXP.upto - SEXP.from); bias = ~bias; ret = alu_reg_get_raw( alu, SEXP, &exp, sizeof(size_t) ); if ( ret != 0 ) { alu_error(ret); return ret; } Inf = (exp == bias); if ( alu_reg_floating( DST ) ) { alu_reg_init( alu, DEXP, DST.node, 0 ); DEXP.upto = DST.upto - 1; DEXP.from = DST.from + DST.mant; DMAN.upto = DST.from + DST.mant; DMAN.from = DST.from; D = alu_reg_data( alu, DST ); /* Set +/- */ d = alu_bit_set_bit( D, DEXP.upto ); *(d.ptr) &= ~(d.mask); *(d.ptr) |= (neg * d.mask); /* Simplify code and pass on duties to another instance, added * bonus of setting Infinity if >= Exponent limit */ alu_reg_mov( alu, DEXP, SEXP ); ndiff = DMAN.upto - DMAN.from; vdiff = SMAN.upto - SMAN.from; /* Make sure we copy the upper bits of the src mantissa */ SMAN.from = SMAN.upto - LOWEST( ndiff, vdiff ); /* Whether it is NaN or a fittable number copying the mantissa * is fine as long as we make sure it was not Infinity to begin * with */ return Inf ? alu_reg_clr( alu, DMAN ) : alu_reg_mov( alu, DMAN, SMAN ); } else if ( Inf ) { s = alu_reg_end_bit( alu, SMAN ); /* NaN cannot be recorded by an integer, use 0 instead */ if ( *(s.ptr) & s.mask ) return alu_reg_clr( alu, DST ); /* Infinity cannot be recorded by an integer, * use min/max instead */ (void)alu_reg_set_max( alu, DST ); return neg ? alu_reg_not( alu, DST ) : 0; } /* Check if exponent is negative - meaning the number is between * 0 & 1, if it is then just set the integer to 0 */ bias >>= 1; if ( exp < bias ) return alu_reg_clr( alu, DST ); exp -= bias; ndiff = DST.upto - DST.from; /* Check if number is to big to fit in the integer */ if ( (exp + SMAN.mant + 1) > ndiff ) { (void)alu_reg_set_max( alu, DST ); return neg ? alu_reg_not( alu, DST ) : 0; } /* alu_reg_get_raw() will have retrieved and released a register, * since that succeeded will end up with that register here as the * register was not released from memory, only usage */ /* Mantissas have an assumed bit, * in this case it's value can only be 1 */ vdiff = 1; (void)alu_reg_set_raw( alu, DST, &vdiff, 1, 0 ); (void)alu_get_reg_node( alu, &tmp, 0 ); alu_reg_init( alu, TMP, tmp, 0 ); /* These cannot possibly fail at this point */ (void)alu_reg__shl( alu, DST, TMP, SRC.mant ); (void)alu_reg__or( alu, DST, SMAN ); (void)alu_reg__shl( alu, DST, TMP, exp - bias ); alu_rem_reg_node( alu, &tmp ); return 0; } ndiff = DST.upto - DST.from; vdiff = SRC.upto - SRC.from; D = alu_reg_data( alu, DST ); S = alu_reg_data( alu, SRC ); d = alu_bit_set_bit( D, DST.from ); s = alu_bit_set_bit( S, SRC.from ); upto = DST.from + LOWEST( ndiff, vdiff ); for ( ; d.bit < upto; alu_bit_inc(&d), alu_bit_inc(&s) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( *(s.ptr) & s.mask, d.mask ); } for ( ; d.bit < DST.upto; alu_bit_inc(&d) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( neg, d.mask ); } return 0; } alu_error( ret ); return ret; }

K, there was a bug but I've fixed that now, I gotta head off to work now, I also have work 2mw so won't be doing any fixes or searching for bugs until after work 2mw. In the off chance someone feels like looking through here's the function with a spot I think is buggy marked with a comment

Code:

int alu_reg_mov ( alu_t *alu, alu_reg_t DST, alu_reg_t SRC ) { int ret; void *D, *S; uint_t tmp = 0; alu_bit_t d, s; size_t ndiff, vdiff, nman_dig, vman_dig, upto, exp, bias; bool neg, Inf = false; alu_reg_t DEXP, DMAN, SEXP, SMAN, TMP; ret = alu_reg_clr( alu, DST ); if ( ret == 0 ) { DST.node %= alu_used( alu ); SRC.node %= alu_used( alu ); ndiff = DST.upto - DST.from; vdiff = SRC.upto - SRC.from; /* Check for +/- */ neg = alu_reg_below0( alu, SRC ); if ( alu_reg_floating( SRC ) ) { alu_reg_init( alu, SEXP, SRC.node, 0 ); alu_reg_init( alu, SMAN, SRC.node, 0 ); vman_dig = alu_man_dig(vdiff); SEXP.upto = SRC.upto - 1; SMAN.upto = SEXP.from = SRC.from + vman_dig; SMAN.from = SRC.from; bias = -1; bias <<= (SEXP.upto - SEXP.from); bias = ~bias; ret = alu_reg_get_raw( alu, SEXP, &exp, sizeof(size_t) ); if ( ret != 0 ) { alu_error(ret); return ret; } Inf = (exp == bias); if ( alu_reg_floating( DST ) ) { alu_reg_init( alu, DEXP, DST.node, 0 ); alu_reg_init( alu, DMAN, DST.node, 0 ); nman_dig = alu_man_dig( ndiff ); DEXP.upto = DST.upto - 1; DMAN.upto = DEXP.from = DST.from + nman_dig; DMAN.from = DST.from; D = alu_reg_data( alu, DST ); /* Set +/- */ d = alu_bit_set_bit( D, DEXP.upto ); *(d.ptr) &= ~(d.mask); *(d.ptr) |= (neg * d.mask); /* Simplify code and pass on duties to another instance, added * bonus of setting Infinity if >= Exponent limit */ alu_reg_mov( alu, DEXP, SEXP ); ndiff = DMAN.upto - DMAN.from; vdiff = SMAN.upto - SMAN.from; /* Make sure we copy the upper bits of the src mantissa */ SMAN.from = SMAN.upto - LOWEST( ndiff, vdiff ); /* Whether it is NaN or a fittable number copying the mantissa * is fine as long as we make sure it was not Infinity to begin * with */ return Inf ? alu_reg_clr( alu, DMAN ) : alu_reg_mov( alu, DMAN, SMAN ); } if ( Inf ) { s = alu_reg_end_bit( alu, SMAN ); /* NaN cannot be recorded by an integer, use 0 instead */ if ( *(s.ptr) & s.mask ) return alu_reg_clr( alu, DST ); /* Infinity cannot be recorded by an integer, * use min/max instead */ (void)alu_reg_set_max( alu, DST ); return neg ? alu_reg_not( alu, DST ) : 0; } /* Check if exponent is negative - meaning the number is between * 0 & 1, if it is then just set the integer to 0 */ bias >>= 1; if ( exp < bias ) return alu_reg_clr( alu, DST ); exp -= bias; /* Check if number is to big to fit in the integer */ if ( (exp + vman_dig + 1) > ndiff ) { (void)alu_reg_set_max( alu, DST ); return neg ? alu_reg_not( alu, DST ) : 0; } /* alu_reg_get_raw() will have retrieved and released a register, * since that succeeded will end up with that register here as the * register was not released from memory, only usage */ /* Mantissas have an assumed bit, * in this case it's value can only be 1 */ ndiff = 1; (void)alu_reg_set_raw( alu, DST, &ndiff, 1, 0 ); (void)alu_get_reg_node( alu, &tmp, 0 ); alu_reg_init( alu, TMP, tmp, 0 ); /* These cannot possibly fail at this point */ (void)alu_reg__shl( alu, DST, TMP, vman_dig ); (void)alu_reg__or( alu, DST, SMAN ); (void)alu_reg__shl( alu, DST, TMP, exp ); alu_rem_reg_node( alu, &tmp ); return 0; } if ( alu_reg_floating( DST ) ) { alu_reg_init( alu, DEXP, DST.node, 0 ); alu_reg_init( alu, DMAN, DST.node, 0 ); nman_dig = alu_man_dig(ndiff); DEXP.upto = DST.upto - 1; DMAN.upto = DEXP.from = DST.from + nman_dig; DMAN.from = DST.from; bias = -1; bias <<= (DEXP.upto - DEXP.from); bias = ~bias; bias >>= 1; s = alu_reg_end_bit( alu, SRC ); if ( s.bit >= bias ) { D = alu_reg_data( alu, DST ); d = alu_bit_set_bit( D, DEXP.upto ); /* Set +/- */ *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( neg, d.mask ); /* Set Infinity */ alu_reg_set_max( alu, DEXP ); /* Clear mantissa so not treated as NaN */ return alu_reg_clr( alu, DMAN ); } /* FIXME: I think there is a bug here */ exp = bias + s.bit; ret = alu_reg_set_raw( alu, DEXP, &exp, sizeof(size_t), 0 ); return alu_reg_mov( alu, DMAN, SRC ); } D = alu_reg_data( alu, DST ); S = alu_reg_data( alu, SRC ); d = alu_bit_set_bit( D, DST.from ); s = alu_bit_set_bit( S, SRC.from ); upto = DST.from + LOWEST( ndiff, vdiff ); for ( ; d.bit < upto; alu_bit_inc(&d), alu_bit_inc(&s) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( *(s.ptr) & s.mask, d.mask ); } for ( ; d.bit < DST.upto; alu_bit_inc(&d) ) { *(d.ptr) &= ~(d.mask); *(d.ptr) |= SET1IF( neg, d.mask ); } return 0; } alu_error( ret ); return ret; }

I've been trying an trying to figure this one out myself but have not found the source of the issue as yet, basically sometimes when acquiring new registers the ALU just overwrites the boolean that states if an allocated register is in use or not, I've even resorted to using a dedicated function for setting and getting that boolean yet still no avail, I've checked that function thoroughly with this:

Code:

START_TEST( test_alu_set_bit ) { ck_assert( alu_upto(alu) > 0 ); uintmax_t num[] = {0,0}, val[] = {0,0}, i = _i; if ( i >= bitsof(uintmax_t) ) num[1] = 1uLL << _i % bitsof(uintmax_t); else num[0] = 1uLL << _i; alu_set_bit( val, _i, 1 ); ck_assert_msg ( memcmp( num, val, sizeof(uintmax_t) * 2 ) == 0 , "Expected 0x%016jX%016jX, Got 0x%016jX%016jX" , num[0], num[1] , val[0], val[1] ); } END_TEST

The function itself looks like this:

Code:

alu_bit_t alu_bit( uintmax_t *ptr, size_t bit ) { alu_bit_t alu_bit = {0}; alu_bit.bit = bit; alu_bit.pos = bit % bitsof(uintmax_t); alu_bit.seg = bit / bitsof(uintmax_t); alu_bit.ptr = ptr + (alu_bit.seg); alu_bit.mask = UNIC_SIZE_C(1) << alu_bit.pos; return alu_bit; } bool alu_get_bit( uintmax_t *ptr, size_t bit ) { alu_bit_t b = alu_bit( ptr, bit ); return !!(*(b.ptr) & b.mask); } void alu_set_bit( uintmax_t *ptr, size_t bit, bool val ) { alu_bit_t b = alu_bit( ptr, bit ); *(b.ptr) &= ~(b.mask); *(b.ptr) |= SET1IF( val, b.mask ); }

The function I tracked the loss of state to is this one so far:

Code:

#define alu_get_active( alu, reg ) alu_get_bit( (void*)alu_valid(alu), reg ) #define alu_clr_active( alu, reg ) alu_set_bit( (void*)alu_valid(alu), reg, 0 ) #define alu_set_active( alu, reg ) alu_set_bit( (void*)alu_valid(alu), reg, 1 ) ... uint_t alu_get_reg_node( alu_t *alu, size_t Nsize ) { uint_t count = 0, index, reg; if ( alu ) { index = ALU_REG_ID_NEED; count = alu_used( alu ); for ( reg = index; index < count; ++index ) { reg = index; count = SET1IF( alu_get_active( alu, index ), count ); } index = HIGHEST( count, reg ); count = HIGHEST( index + 1, alu_used(alu) ); Nsize = HIGHEST( Nsize, alu_Nsize( alu ) ); reg = HIGHEST( count, alu_upto( alu ) ); alu_errno(alu) = alu_setup_reg( alu, reg, Nsize ); if ( alu_errno(alu) ) { alu_error( alu_errno(alu) ); return 0; } alu_used( alu ) = count; (void)memset( alu_data( alu, index ), 0, Nsize ); alu_set_active( alu, index ); return index; } (void)alu_err_null_ptr( "alu" ); return 0; }

At this point I'm seriously considering adding a temporary parameter to this function just to track the boolean until it clears inappropriately like in my tests. Before I do that does anyone have any ideas what might be happening? As a reminder the link to current code is in my signature.

Found the problem, when I switched to using the 1st register for storing active state booleans I forgot to change the starting index for alu_set_constants(), fixed and now getting behavior I expect

Anyone know why this would be reported?

Code:

realloc(): invalid next size

I can't get the current version pulled from GitHub to build.

I can't bench-check the functioning of your code as it feels too weird, preventing me from seeing what is going on.

That code feels weird to me for the following reason:

- The for loop assigns reg as the initial setup, even though it isn't used in the test expression.

- reg is assigned again in the loop body, to the same value, making the initial assignment not required.

- The value of count is modified in the for loop to cause it to exit, which is an unusual pattern. It also breaks my understanding of count, as it is no longer the count of registers that have been used.

- The assignments following the loop have a a function of count assigned to index, and then a function of index assigned to count. This is playing mental "follow the ball under the shell" game as I try to follow which variable means what at which point.

- The 'reg' variable isn't really needed and confuses things, seems to be a hangover from earlier versions. Maybe.

- Assigning a value into the result of the alu_used() function isn't C-like.

If I was to rewrite it, to match my understanding of what is going on I would do it like this:

Code:

uint_t alu_get_reg_node( alu_t *alu, size_t Nsize ) { if (!alu ) { (void)alu_err_null_ptr( "alu" ); return 0; } // Work out size of register if(alu_Nsize(alu)) > Nsize) Nsize = alu_Nsize( alu ); // Hunt for the first unused reg uint_t index = ALU_REG_NEEDED; while(index < alu_used(alu) && alu_get_active( alu, index )) index++; // Try to set up that register - will fail if out of registers alu_errno(alu) = alu_setup_reg( alu, index, Nsize ); if ( alu_errno(alu) ) { alu_error( alu_errno(alu) ); return 0; } // Did we need to use a new register? if(index == alu_used(alu)) alu_used( alu ) = alu_used(alu)+1; } // Empty out the newly allocated register and mark it active memset( alu_data( alu, index ), 0, Nsize ); alu_set_active( alu, index ); return index; }

I know it doesn't fit the style of the project, but I feel that the intent of the code is much clearer.

Quote:

Originally Posted by awsdert

Anyone know why this would be reported?

Code:

realloc(): invalid next size

Short answer: Usually it means that you you have corrupted your heap by accessing more memory then you have allocated.

Long answer: Malloc allocates memory in chunks that are rounded up in size to be aligned to a particular address boundary.

When you call realloc() looks at the next block of memory to see if it can use it to satisfy the request. Malloc has discovered that the size field for that block has been corrupted.

Quote:

Originally Posted by hamster_nz

Short answer: Usually it means that you you have corrupted your heap by accessing more memory then you have allocated.

Long answer: Malloc allocates memory in chunks that are rounded up in size to be aligned to a particular address boundary.

When you call realloc() looks at the next block of memory to see if it can use it to satisfy the request. Malloc has discovered that the size field for that block has been corrupted.

I'll answer this one 1st, just a few minutes ago I found that it was because I was using the same size for reallocation, which apparently means realloc is not designed to just give back the old pointer and pretend it was never called in that situation (despite that being the obvious thing to do)

Quote:

Originally Posted by awsdert

I'll answer this one 1st, just a few minutes ago I found that it was because I was using the same size for reallocation, which apparently means realloc is not designed to just give back the old pointer and pretend it was never called in that situation (despite that being the obvious thing to do)

I would put money on you corrupting the heap. The corurption will only be visible when something calls realloc(), free(), realloc() or related functions:

Here's a small test program that will recreate a "realloc(): invalid next size" error. Note how it allocates 100 bytes, then clears 120.

Code:

#include <malloc.h> #include <stdio.h> #include <memory.h> int main(int argc, char *argv[]) { char *ptr1; ptr1 = malloc(100); if(ptr1 == NULL) { printf("failled to malloc\n"); return 0; } // Corrupt the heap memset(ptr1,0,120); // Now try the realloc ptr1 = realloc(ptr1,120); return 0; }

And the output when it is run:

Code:

~/realloc_test$ ./realloc_test realloc(): invalid next size Aborted (core dumped)

These memory corruption issues are a complete pain to debug.

On Linux, if you add a call to mcheck() (defined in mcheck.h) before you use any of the malloc functions you will get better debug infor:

Code:

hamster@hamster-envy:~/realloc_test$ cat realloc_test.c #include <malloc.h> #include <stdio.h> #include <mcheck.h> #include <memory.h> int main(int argc, char *argv[]) { char *ptr1; mcheck(NULL); ptr1 = malloc(100); if(ptr1 == NULL) { printf("failled to malloc\n"); return 0; } // Corrupt the heap memset(ptr1,0,120); // Now try the realloc ptr1 = realloc(ptr1,120); return 0; } hamster@hamster-envy:~/realloc_test$ ./realloc_test memory clobbered past end of allocated block Aborted (core dumped)

Quote:

Originally Posted by hamster_nz

I can't get the current version pulled from GitHub to build.

I can't bench-check the functioning of your code as it feels too weird, preventing me from seeing what is going on.

That code feels weird to me for the following reason:

- The for loop assigns reg as the initial setup, even though it isn't used in the test expression.

- reg is assigned again in the loop body, to the same value, making the initial assignment not required.

- The value of count is modified in the for loop to cause it to exit, which is an unusual pattern. It also breaks my understanding of count, as it is no longer the count of registers that have been used.

- The assignments following the loop have a a function of count assigned to index, and then a function of index assigned to count. This is playing mental "follow the ball under the shell" game as I try to follow which variable means what at which point.

- The 'reg' variable isn't really needed and confuses things, seems to be a hangover from earlier versions. Maybe.

- Assigning a value into the result of the alu_used() function isn't C-like.

If I was to rewrite it, to match my understanding of what is going on I would do it like this:

Code:

uint_t alu_get_reg_node( alu_t *alu, size_t Nsize ) { if (!alu ) { (void)alu_err_null_ptr( "alu" ); return 0; } // Work out size of register if(alu_Nsize(alu)) > Nsize) Nsize = alu_Nsize( alu ); // Hunt for the first unused reg uint_t index = ALU_REG_NEEDED; while(index < alu_used(alu) && alu_get_active( alu, index )) index++; // Try to set up that register - will fail if out of registers alu_errno(alu) = alu_setup_reg( alu, index, Nsize ); if ( alu_errno(alu) ) { alu_error( alu_errno(alu) ); return 0; } // Did we need to use a new register? if(index == alu_used(alu)) alu_used( alu ) = alu_used(alu)+1; } // Empty out the newly allocated register and mark it active memset( alu_data( alu, index ), 0, Nsize ); alu_set_active( alu, index ); return index; }

I know it doesn't fit the style of the project, but I feel that the intent of the code is much clearer.

For reader's reference hamster_nz is talking about this code:

Code:

uint_t alu_get_reg_node( alu_t *alu, size_t Nsize ) { uint_t count = 0, index, reg; if ( alu ) { index = ALU_REG_ID_NEED; count = alu_used( alu ); for ( reg = index; index < count; ++index ) { reg = index; count = SET1IF( alu_get_active( alu, index ), count ); } index = HIGHEST( count, reg ); count = HIGHEST( index + 1, alu_used(alu) ); Nsize = HIGHEST( Nsize, alu_Nsize( alu ) ); reg = HIGHEST( count, alu_upto( alu ) ); alu_errno(alu) = alu_setup_reg( alu, reg, Nsize ); if ( alu_errno(alu) ) { alu_error( alu_errno(alu) ); return 0; } alu->taken = count; (void)memset( alu_data( alu, index ), 0, Nsize ); alu_set_active( alu, index ); return index; } (void)alu_err_null_ptr( "alu" ); return 0; }

- count is cleared for the sake of avoiding an additional branch (which slows code normally - read up on how CPUs treat branch instructions to understand what I mean), as you'll note shortly after the loop count is overwritten with the next expected used registers count, in the case an available register was found it will be the old count, in the case that no register was found then it will be the index (which itself is either the original count or an available register) + 1
- reg is only used to hold the value of index before it is incremented, it is given back in the case count was cleared, after that the variable has no particular purpose so I reused it for holding the total registers to allocate (which is usually the existing amount, only higher if count is higher)
- Using !alu for branching is bad because at every branch the CPU preloads instructions with the assumption that the result will be true, when false it has to throw away that preload and load the correct instructions, this is why I now place code for false results after the if statement (whether it is in an else statement or otherwise)
- assigning a value to alu_used(alu) is fine when the "function" is nothing more than a macro to the value that can be overwritten, this can also happen with errno last I checked so it is considered acceptable in the right situations
- Your rewrite has too many branches and would inevitably slow down the ALU so I won't be using it

Here's that same code, where it doesn't smash the heap.

Code:

#include <malloc.h> #include <stdio.h> #include <mcheck.h> #include <memory.h> int main(int argc, char *argv[]) { char *ptr1; mcheck(NULL); ptr1 = malloc(120); if(ptr1 == NULL) { printf("failled to malloc\n"); return 0; } // Don't corrupt the heap memset(ptr1,0,120); // Now try the realloc ptr1 = realloc(ptr1,120); printf("Success\n"); free(ptr1); return 0; }

It prints "success" as expected, even after realloc()ing to the same size.

Going back to my problem with realloc(), while adjusting the requested size handling did allow it to get further (and even create a speedup for alu_block()) it still has some issue crop up, here's the output before the test came to a screeching halt.

Code:

make rebuild check cd ../ && make --no-print-directory rebuild check #MAKECMDGOALS=rebuild check cd mak && make -j 1 --no-print-directory -f main.mak rebuild check PRJ_LIB_NAME=alu_d Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=check_alu_d.AppImage PRJ_DST_LIB=libalu_d.so rm -f ../bin/*.AppImage ../bin/*.exe rm -f ../lib/*.so ../lib/*.dll rm -f ../src/*.o ../src/*.obj rm -f ../tests/*.o ../tests/*.obj cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit_d.o -c ../src/alu_bit.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn_d.o -c ../src/alu_fpn.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int_d.o -c ../src/alu_int.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main_d.o -c ../src/alu_main.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math_d.o -c ../src/alu_math.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem_d.o -c ../src/alu_mem.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint_d.o -c ../src/alu_uint.c cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec_d.o -c ../src/alu_vec.c cc -ggdb -D _DEBUG -O0 -fPIC -shared -o ../lib/libalu_d.so ../src/alu_bit_d.o ../src/alu_fpn_d.o ../src/alu_int_d.o ../src/alu_main_d.o ../src/alu_math_d.o ../src/alu_mem_d.o ../src/alu_uint_d.o ../src/alu_vec_d.o -Wl,-rpath,../lib cc -ggdb -D _DEBUG -O0 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu_d.o -c ../tests/check_alu.c In file included from ../tests/check_alu.c:181: ../tests/check_alu.c:491:13: warning: ‘test_alu_reg2str’ defined but not used [-Wunused-variable] 491 | START_TEST( test_alu_reg2str ) | ^~~~~~~~~~~~~~~~ ../tests/check_alu.c:356:13: warning: ‘test_alu_op3’ defined but not used [-Wunused-variable] 356 | START_TEST( test_alu_op3 ) | ^~~~~~~~~~~~ cc -ggdb -D _DEBUG -O0 -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check ../bin/check_alu_d.AppImage ../tests/check_alu.c:864: main() 'Running unit tests under 'check' test suite' Running suite(s): ALU ../src/alu_mem.c:68: alu_block() want = 512, size = 544, given = 0 ../src/alu_mem.c:30: alu_block() want = 1040, size = 1072, given = 512 ../src/alu_mem.c:30: alu_block() want = 1056, size = 1088, given = 1040 ../src/alu_mem.c:30: alu_block() want = 1072, size = 1104, given = 1056 ../src/alu_mem.c:30: alu_block() want = 1088, size = 1120, given = 1072 ../src/alu_mem.c:30: alu_block() want = 1104, size = 1136, given = 1088 ../src/alu_mem.c:30: alu_block() want = 1120, size = 1152, given = 1104 ../src/alu_mem.c:30: alu_block() want = 1136, size = 1168, given = 1120 ../src/alu_mem.c:30: alu_block() want = 1152, size = 1184, given = 1136 ../src/alu_mem.c:30: alu_block() want = 1168, size = 1200, given = 1152 ../src/alu_mem.c:30: alu_block() want = 1184, size = 1216, given = 1168 ../src/alu_mem.c:30: alu_block() want = 1200, size = 1232, given = 1184 ../src/alu_mem.c:30: alu_block() want = 1216, size = 1248, given = 1200 ../src/alu_mem.c:30: alu_block() want = 1232, size = 1264, given = 1216 ../src/alu_mem.c:30: alu_block() want = 1248, size = 1280, given = 1232 ../src/alu_mem.c:30: alu_block() want = 1264, size = 1296, given = 1248 ../src/alu_mem.c:30: alu_block() want = 1280, size = 1312, given = 1264 ../src/alu_mem.c:30: alu_block() want = 1296, size = 1328, given = 1280 ../src/alu_mem.c:30: alu_block() want = 1312, size = 1344, given = 1296 ../src/alu_mem.c:30: alu_block() want = 1328, size = 1360, given = 1312 ../src/alu_mem.c:30: alu_block() want = 1344, size = 1376, given = 1328 ../src/alu_mem.c:30: alu_block() want = 1360, size = 1392, given = 1344 ../src/alu_mem.c:30: alu_block() want = 1376, size = 1408, given = 1360 ../src/alu_mem.c:30: alu_block() want = 1392, size = 1424, given = 1376 ../src/alu_mem.c:30: alu_block() want = 1408, size = 1440, given = 1392 ../src/alu_mem.c:30: alu_block() want = 1424, size = 1456, given = 1408 ../src/alu_mem.c:30: alu_block() want = 1440, size = 1472, given = 1424 ../src/alu_mem.c:30: alu_block() want = 1456, size = 1488, given = 1440 ../src/alu_mem.c:30: alu_block() want = 1472, size = 1504, given = 1456 ../src/alu_mem.c:30: alu_block() want = 1488, size = 1520, given = 1472 ../src/alu_mem.c:30: alu_block() want = 1504, size = 1536, given = 1488 ../src/alu_mem.c:30: alu_block() want = 1520, size = 1552, given = 1504 ../src/alu_mem.c:30: alu_block() want = 1536, size = 1568, given = 1520 ../src/alu_mem.c:30: alu_block() want = 1552, size = 1584, given = 1536 ../src/alu_mem.c:30: alu_block() want = 1568, size = 1600, given = 1552 ../src/alu_mem.c:30: alu_block() want = 1584, size = 1616, given = 1568 ../src/alu_mem.c:30: alu_block() want = 1600, size = 1632, given = 1584 ../src/alu_mem.c:30: alu_block() want = 1616, size = 1648, given = 1600 ../src/alu_mem.c:30: alu_block() want = 1632, size = 1664, given = 1616 ../src/alu_mem.c:30: alu_block() want = 1648, size = 1680, given = 1632 ../src/alu_mem.c:30: alu_block() want = 1664, size = 1696, given = 1648 ../src/alu_mem.c:30: alu_block() want = 1680, size = 1712, given = 1664 ../src/alu_mem.c:30: alu_block() want = 1696, size = 1728, given = 1680 ../src/alu_mem.c:30: alu_block() want = 1712, size = 1744, given = 1696 ../src/alu_mem.c:30: alu_block() want = 1728, size = 1760, given = 1712 ../src/alu_mem.c:30: alu_block() want = 1744, size = 1776, given = 1728 ../src/alu_mem.c:30: alu_block() want = 1760, size = 1792, given = 1744 ../src/alu_mem.c:30: alu_block() want = 1776, size = 1808, given = 1760 ../src/alu_mem.c:30: alu_block() want = 1792, size = 1824, given = 1776 ../src/alu_mem.c:30: alu_block() want = 1808, size = 1840, given = 1792 ../src/alu_mem.c:30: alu_block() want = 1824, size = 1856, given = 1808 ../src/alu_mem.c:30: alu_block() want = 1840, size = 1872, given = 1824 ../src/alu_mem.c:30: alu_block() want = 1856, size = 1888, given = 1840 ../src/alu_mem.c:30: alu_block() want = 1872, size = 1904, given = 1856 ../src/alu_mem.c:30: alu_block() want = 1888, size = 1920, given = 1872 ../src/alu_mem.c:30: alu_block() want = 1904, size = 1936, given = 1888 ../src/alu_mem.c:30: alu_block() want = 1920, size = 1952, given = 1904 ../src/alu_mem.c:30: alu_block() want = 1936, size = 1968, given = 1920 ../src/alu_mem.c:30: alu_block() want = 1952, size = 1984, given = 1936 ../src/alu_mem.c:30: alu_block() want = 1968, size = 2000, given = 1952 ../src/alu_mem.c:30: alu_block() want = 1984, size = 2016, given = 1968 ../src/alu_mem.c:30: alu_block() want = 2000, size = 2032, given = 1984 ../src/alu_mem.c:30: alu_block() want = 2016, size = 2048, given = 2000 ../src/alu_mem.c:30: alu_block() want = 2032, size = 2064, given = 2016 check_alu_d.AppImage: malloc.c:2394: sysmalloc: Assertion `(old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)' failed. make[2]: *** [main.mak:99: check] Aborted (core dumped) rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o make[1]: *** [makefile:10: rebuild] Error 2 make: *** [makefile:4: rebuild] Error 2 Compilation failed.

Quote:

- count is cleared for the sake of avoiding an additional branch (which slows code normally - read up on how CPUs treat branch instructions to understand what I mean), as you'll note shortly after the loop count is overwritten with the next expected used registers count, in the case an available register was found it will be the old count, in the case that no register was found then it will be the index (which itself is either the original count or an available register) + 1

I know that branching is generally bad. In the recent past I have worked on CPU branch prediction H/W design... but I think you are overly pessimistic on how bad it is. The 90/10 rule apply - you only have to optimise 10% of the code to get 90% of the benefit. When it comes to code optimisation objective timings win over dogma...

Quote:

- reg is only used to hold the value of index before it is incremented, it is given back in the case count was cleared, after that the variable has no particular purpose so I reused it for holding the total registers to allocate (which is usually the existing amount, only higher if count is higher)

Reusing a variable just because it is there lowers the readability of the code and may also hinders the compilers ability to do optimizations or print helpful messages like "Opps - you are not initialising this variable before use".

Quote:

- Using !alu for branching is bad because at every branch the CPU preloads instructions with the assumption that the result will be true, when false it has to throw away that preload and load the correct instructions, this is why I now place code for false results after the if statement (whether it is in an else statement or otherwise)

This is mostly false on modern CPUs. The instruction fetch unit of modern CPUs uses branch prediction to and speculative execution to have the right instructions decoded and in flight most of the time. Modern CPUs recognise patterns, so it the last few conditional branches have a previously seen pattern it will expect the pattern to continue.
This allows the cpu to predict things like

Code:

for(i = 0; i < 4; i++) {....}

and not miss-predict during the last pass of the loop.

It's a really big topic, the Wikipedia page Branch predictor - Wikipedia only scratches the surface.

Also, compilers can also move around blocks of code, and even duplicate them (i.e. unrolling loops), which mean that the relationships you see in the source may not be present in the generated instruction stream.

Quote:

- assigning a value to alu_used(alu) is fine when the "function" is nothing more than a macro to the value that can be overwritten, this can also happen with errno last I checked so it is considered acceptable in the right situations

Sure it is legal, but is quirky, You have to be aware that "alu_used(alu)" is macro, so "alu_used(alu) = whatever;" could just written "alu->taken = whatever;"

Quote:

- Your rewrite has too many branches and would inevitably slow down the ALU so I won't be using it

Although I don't agree, I'm fine with that. One can only offer advice, not force it to be taken....

As an example of false optimization, take HIGHEST(a,b) on my x64 platform.

Here's your version:

Code:

#define HIGHEST( A, B ) ( ((A) * ((A) >= (B))) | ((B) * ((B) >= (A))) )

It compiles down to this instruction stream:

Code:

xorl %edx, %edx cmpl %ebx, %eax setle %dl xorl %ecx, %ecx imull %ebx, %edx cmpl %ebx, %eax setge %cl

but this version:

Code:

#define HIGHEST( A, B ) ( A > B ? A : B)

Compiles down to the (still branchless) but much quicker:

Code:

cmpl %eax, %ebx cmovg %ebx, %eax

Quote:

Originally Posted by hamster_nz

I know that branching is generally bad. In the recent past I have worked on CPU branch prediction H/W design... but I think you are overly pessimistic on how bad it is. The 90/10 rule apply - you only have to optimise 10% of the code to get 90% of the benefit. When it comes to code optimisation objective timings win over dogma...

Reusing a variable just because it is there lowers the readability of the code and may also hinders the compilers ability to do optimizations or print helpful messages like "Opps - you are not initialising this variable before use".

This is mostly false on modern CPUs. The instruction fetch unit of modern CPUs uses branch prediction to and speculative execution to have the right instructions decoded and in flight most of the time. Modern CPUs recognise patterns, so it the last few conditional branches have a previously seen pattern it will expect the pattern to continue.
This allows the cpu to predict things like

Code:

for(i = 0; i < 4; i++) {....}

and not miss-predict during the last pass of the loop.

It's a really big topic, the Wikipedia page Branch predictor - Wikipedia only scratches the surface.

Also, compilers can also move around blocks of code, and even duplicate them (i.e. unrolling loops), which mean that the relationships you see in the source may not be present in the generated instruction stream.

Sure it is legal, but is quirky, You have to be aware that "alu_used(alu)" is macro, so "alu_used(alu) = whatever;" could just written "alu->taken = whatever;"

Although I don't agree, I'm fine with that. One can only offer advice, not force it to be taken....

It's not about being pessimistic, it's just I consider using slower code to be a fore-par when you know there is faster code you can use, ideally I would do this all in ASM and eliminate branching altogether by utilizing some relative address loading instruction and the multiply instruction (or shift if no such instruction is available) but my ASM skill/knowledge are poor at the moment so I can't.

Managed to resolve my memory issues (not the ones in my head though :D) by using mmap instead, aside from needing a windows equivalent - which I think was call VirtualMemoryAlloc() - is there any potential problems anyone sees in the code here:
Apparently realloc cannot be relied upon for acquiring available memory, * awsdert/alu@6a204dc * GitHub

Quote:

Originally Posted by awsdert

Managed to resolve my memory issues (not the ones in my head though :D) by using mmap instead, aside from needing a windows equivalent - which I think was call VirtualMemoryAlloc() - is there any potential problems anyone sees in the code here:
Apparently realloc cannot be relied upon for acquiring available memory, * awsdert/alu@6a204dc * GitHub

You have hidden the bug, not fixed it. Nine out of ten chance that it will come back to bite you with random corruptions and inexplicable issues

Realloc() does work, but only as long as you don't clobber the heap by writing to memory outside of your allocations

Quote:

Originally Posted by hamster_nz

You have hidden the bug, not fixed it. Nine out of ten chance that it will come back to bite you with random corruptions and inexplicable issues

Realloc() does work, but only as long as you don't clobber the heap by writing to memory outside of your allocations

No it doesn't fully work, I had tracked the overwrite down to a situation where realloc had returned a valid pointer but never actually acquired the needed memory, leaving my code to believe it succeeded and carry on as though it had done so, where I had check the return code I switched to checking the memory given against the expected memory and found after a dozen or so realloc's the memory given turned out to be smaller than expected but because I had checked the return code instead of the given bytes I ran into a memory clobber situation, after using mmap() the situation just vanished, and frankly since the ALU will need to be optimised anyways mmap() is the better choice anyways, at least there I can skip assigning memory for the parameters that shouldn't have been appended but prepended to the memory given

Quote:

Originally Posted by awsdert

No it doesn't fully work, I had tracked the overwrite down to a situation where realloc had returned a valid pointer but never actually acquired the needed memory, leaving my code to believe it succeeded and carry on as though it had done so

Are you sure you don't have a bug resulting in undefined behaviour elsewhere?

Having said that, yes, I believe it is true that on Linux malloc and presumably also realloc is not guaranteed to return a null pointer on allocation failure.

Quote:

Originally Posted by awsdert

No it doesn't fully work, I had tracked the overwrite down to a situation where realloc had returned a valid pointer but never actually acquired the needed memory, leaving my code to believe it succeeded and carry on as though it had done so, where I had check the return code

The likelihood of that is very, very small. realloc() is a very old function, and is very much in use. I would hazard a guess that the reason it now works is that under the covers mmap() allocates memory in full pages.

I'ld find the error and fix it for you if your GitHub repo actually built:

Code:

hamster@hamster-envy:~$ git clone GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs Cloning into 'alu'... remote: Enumerating objects: 71, done. remote: Counting objects: 100% (71/71), done. remote: Compressing objects: 100% (71/71), done. remote: Total 537 (delta 38), reused 33 (delta 0), pack-reused 466 Receiving objects: 100% (537/537), 178.78 KiB | 407.00 KiB/s, done. Resolving deltas: 100% (367/367), done. hamster@hamster-envy:~$ cd alu hamster@hamster-envy:~/alu$ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Cloning into 'unic'... remote: Enumerating objects: 198, done. remote: Counting objects: 100% (198/198), done. remote: Compressing objects: 100% (161/161), done. remote: Total 198 (delta 107), reused 115 (delta 26), pack-reused 0 Receiving objects: 100% (198/198), 61.33 KiB | 286.00 KiB/s, done. Resolving deltas: 100% (107/107), done. Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so mkdir ../bin mkdir ../lib cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from /usr/include/stdio.h:41:0, from ../include/alu.h:11, from ../src/alu_vec.c:1: /usr/include/x86_64-linux-gnu/bits/libio.h:466:58: error: expected declaration specifiers or ‘...’ before ‘)’ token extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t); ^ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

Even when I try to hotwire the build process, things are not right, especially in tests/test_alu.c:

Code:

hamster@hamster-envy:~/alu/src$ gcc -o alu *.c ../tests/test_alu.c -I ../include -I ../cloned/unic/include/ ../tests/test_alu.c: In function ‘rng’: ../tests/test_alu.c:232:6: warning: implicit declaration of function ‘ror’ [-Wimplicit-function-declaration] n = ror( n, X % bitsof(size_t) ); ^~~ ../tests/test_alu.c: In function ‘func_wrChar32’: ../tests/test_alu.c:519:7: warning: assignment makes integer from pointer without a cast [-Wint-conversion] ret = alu_block_expand( dst, dst->taken + 50 ); ^ ../tests/test_alu.c: In function ‘reg_print_value’: ../tests/test_alu.c:556:35: warning: passing argument 2 of ‘alu_get_reg_node’ makes integer from pointer without a cast [-Wint-conversion] int ret = alu_get_reg_node( alu, &tmp, 0 ); ^ In file included from ../tests/test_alu.c:1:0: ../include/alu.h:346:8: note: expected ‘size_t {aka long unsigned int}’ but argument is of type ‘uint_t * {aka unsigned int *}’ uint_t alu_get_reg_node( alu_t *alu, size_t need ); ^~~~~~~~~~~~~~~~ ../tests/test_alu.c:556:12: error: too many arguments to function ‘alu_get_reg_node’ int ret = alu_get_reg_node( alu, &tmp, 0 ); ....

Quote:

Originally Posted by hamster_nz

The likelihood of that is very, very small. realloc() is a very old function, and is very much in use. I would hazard a guess that the reason it now works is that under the covers mmap() allocates memory in full pages.

I'ld find the error and fix it for you if your GitHub repo actually built:

Code:

hamster@hamster-envy:~$ git clone GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs Cloning into 'alu'... remote: Enumerating objects: 71, done. remote: Counting objects: 100% (71/71), done. remote: Compressing objects: 100% (71/71), done. remote: Total 537 (delta 38), reused 33 (delta 0), pack-reused 466 Receiving objects: 100% (537/537), 178.78 KiB | 407.00 KiB/s, done. Resolving deltas: 100% (367/367), done. hamster@hamster-envy:~$ cd alu hamster@hamster-envy:~/alu$ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Cloning into 'unic'... remote: Enumerating objects: 198, done. remote: Counting objects: 100% (198/198), done. remote: Compressing objects: 100% (161/161), done. remote: Total 198 (delta 107), reused 115 (delta 26), pack-reused 0 Receiving objects: 100% (198/198), 61.33 KiB | 286.00 KiB/s, done. Resolving deltas: 100% (107/107), done. Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so mkdir ../bin mkdir ../lib cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from /usr/include/stdio.h:41:0, from ../include/alu.h:11, from ../src/alu_vec.c:1: /usr/include/x86_64-linux-gnu/bits/libio.h:466:58: error: expected declaration specifiers or ‘...’ before ‘)’ token extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t); ^ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

Even when I try to hotwire the build process, things are not right, especially in tests/test_alu.c:

Code:

hamster@hamster-envy:~/alu/src$ gcc -o alu *.c ../tests/test_alu.c -I ../include -I ../cloned/unic/include/ ../tests/test_alu.c: In function ‘rng’: ../tests/test_alu.c:232:6: warning: implicit declaration of function ‘ror’ [-Wimplicit-function-declaration] n = ror( n, X % bitsof(size_t) ); ^~~ ../tests/test_alu.c: In function ‘func_wrChar32’: ../tests/test_alu.c:519:7: warning: assignment makes integer from pointer without a cast [-Wint-conversion] ret = alu_block_expand( dst, dst->taken + 50 ); ^ ../tests/test_alu.c: In function ‘reg_print_value’: ../tests/test_alu.c:556:35: warning: passing argument 2 of ‘alu_get_reg_node’ makes integer from pointer without a cast [-Wint-conversion] int ret = alu_get_reg_node( alu, &tmp, 0 ); ^ In file included from ../tests/test_alu.c:1:0: ../include/alu.h:346:8: note: expected ‘size_t {aka long unsigned int}’ but argument is of type ‘uint_t * {aka unsigned int *}’ uint_t alu_get_reg_node( alu_t *alu, size_t need ); ^~~~~~~~~~~~~~~~ ../tests/test_alu.c:556:12: error: too many arguments to function ‘alu_get_reg_node’ int ret = alu_get_reg_node( alu, &tmp, 0 ); ....

I'll take a closer look at your build problem 2mw after work, as for test_alu.c I might abandon that one altogether now that I'm getting the hang of the check library, anyways for now use make check or make rebuild check as I haven't been maintaining test_alu.c whilst I've been setting up the check_alu.c

Quote:

Originally Posted by hamster_nz

The likelihood of that is very, very small. realloc() is a very old function, and is very much in use. I would hazard a guess that the reason it now works is that under the covers mmap() allocates memory in full pages.

I'ld find the error and fix it for you if your GitHub repo actually built:

Code:

hamster@hamster-envy:~$ git clone GitHub - awsdert/alu: Library modeled after the Arithmetic Logic Unit built into CPUs Cloning into 'alu'... remote: Enumerating objects: 71, done. remote: Counting objects: 100% (71/71), done. remote: Compressing objects: 100% (71/71), done. remote: Total 537 (delta 38), reused 33 (delta 0), pack-reused 466 Receiving objects: 100% (537/537), 178.78 KiB | 407.00 KiB/s, done. Resolving deltas: 100% (367/367), done. hamster@hamster-envy:~$ cd alu hamster@hamster-envy:~/alu$ make build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Cloning into 'unic'... remote: Enumerating objects: 198, done. remote: Counting objects: 100% (198/198), done. remote: Compressing objects: 100% (161/161), done. remote: Total 198 (delta 107), reused 115 (delta 26), pack-reused 0 Receiving objects: 100% (198/198), 61.33 KiB | 286.00 KiB/s, done. Resolving deltas: 100% (107/107), done. Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so mkdir ../bin mkdir ../lib cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c In file included from /usr/include/stdio.h:41:0, from ../include/alu.h:11, from ../src/alu_vec.c:1: /usr/include/x86_64-linux-gnu/bits/libio.h:466:58: error: expected declaration specifiers or ‘...’ before ‘)’ token extern _IO_ssize_t _IO_padn (_IO_FILE *, int, _IO_ssize_t); ^ main.mak:147: recipe for target '../src/alu_vec.o' failed make[1]: *** [../src/alu_vec.o] Error 1 makefile:9: recipe for target 'build' failed make: *** [build] Error 2

Even when I try to hotwire the build process, things are not right, especially in tests/test_alu.c:

Code:

hamster@hamster-envy:~/alu/src$ gcc -o alu *.c ../tests/test_alu.c -I ../include -I ../cloned/unic/include/ ../tests/test_alu.c: In function ‘rng’: ../tests/test_alu.c:232:6: warning: implicit declaration of function ‘ror’ [-Wimplicit-function-declaration] n = ror( n, X % bitsof(size_t) ); ^~~ ../tests/test_alu.c: In function ‘func_wrChar32’: ../tests/test_alu.c:519:7: warning: assignment makes integer from pointer without a cast [-Wint-conversion] ret = alu_block_expand( dst, dst->taken + 50 ); ^ ../tests/test_alu.c: In function ‘reg_print_value’: ../tests/test_alu.c:556:35: warning: passing argument 2 of ‘alu_get_reg_node’ makes integer from pointer without a cast [-Wint-conversion] int ret = alu_get_reg_node( alu, &tmp, 0 ); ^ In file included from ../tests/test_alu.c:1:0: ../include/alu.h:346:8: note: expected ‘size_t {aka long unsigned int}’ but argument is of type ‘uint_t * {aka unsigned int *}’ uint_t alu_get_reg_node( alu_t *alu, size_t need ); ^~~~~~~~~~~~~~~~ ../tests/test_alu.c:556:12: error: too many arguments to function ‘alu_get_reg_node’ int ret = alu_get_reg_node( alu, &tmp, 0 ); ....

test_alu.c has been fixed, the build issue was likely just because I hadn't maintained the file, currently building fine for me now

Code:

make build cd ../ && make --no-print-directory build #MAKECMDGOALS=build cd mak && make -j 1 --no-print-directory -f main.mak build PRJ_LIB_NAME=alu Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=test_alu.AppImage PRJ_DST_LIB=libalu.so cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit.o -c ../src/alu_bit.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn.o -c ../src/alu_fpn.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int.o -c ../src/alu_int.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main.o -c ../src/alu_main.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math.o -c ../src/alu_math.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem.o -c ../src/alu_mem.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint.o -c ../src/alu_uint.c cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec.o -c ../src/alu_vec.c cc -D NDEBUG -O3 -fPIC -shared -o ../lib/libalu.so ../src/alu_bit.o ../src/alu_fpn.o ../src/alu_int.o ../src/alu_main.o ../src/alu_math.o ../src/alu_mem.o ../src/alu_uint.o ../src/alu_vec.o -Wl,-rpath,../lib cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/test_alu.o -c ../tests/test_alu.c cc -D NDEBUG -O3 -fPIE -L ../lib -o ../bin/test_alu.AppImage ../tests/test_alu.o -Wl,-rpath,../lib -l alu rm ../src/alu_math.o ../tests/test_alu.o ../src/alu_main.o ../src/alu_uint.o ../src/alu_mem.o ../src/alu_int.o ../src/alu_bit.o ../src/alu_vec.o ../src/alu_fpn.o Compilation finished successfully.

I see two problems in the latest code I was inspecting:

Your tests need more than 127 registers, but are limited by:

Code:

#define ALU_REG_ID_LIMIT SCHAR_MAX

Confirmed by adding this code in alu_setup_reg:

Code:

want = HIGHEST( want, ALU_REG_ID_NEED ); >> if(want > ALU_REG_ID_LIMIT) { >> alu_printf("Limiting registers to %u",ALU_REG_ID_LIMIT); >> } want = LOWEST( want, ALU_REG_ID_LIMIT );

It appears you need about 510 registers or so to pass your 'check' tests. When you use mmap this is being hidden as you map a full page of memory, which bypass this check and allows for many more registers.

Also in alu_vec.c I think this check is suspect, and most likely wrong:

Code:

>>> if ( Nsize == vec->Nsize) { return vec->block.block; }

What are you testing there, and why?

With these issues addressed the output was identical using mmap() or the earlier malloc/realloc() based code in alu_mem.c.

PS. Build still fails on Ubuntu

To get it to compile I had to move this header file around in alu.h:

Code:

#include <unic/limits.h> #include <errno.h> #include <uchar.h> #include <float.h> #include <ctype.h> #include <string.h> #include <stdio.h> #include <unic/stdint.h>

And then the link process fails with this error:

Code:

cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/7/../../../x86_64-linux-gnu/libcheck.a(check_run.o): undefined reference to symbol 'timer_settime@@GLIBC_2.3.3' //lib/x86_64-linux-gnu/librt.so.1: error adding symbols: DSO missing from command line

The linkage error can be resolved by adding the following libraries required to support 'check': libm libpthread libsubunit librt

Currently building by running this in ./src:

Code:

gcc -o alu *.c ../tests/check_alu.c -I ../include/ -I ../cloned/unic/include/ -l check -l subunit -l rt -l pthread -lm

Quote:

Originally Posted by hamster_nz

I see two problems in the latest code I was inspecting:

Your tests need more than 127 registers, but are limited by:

Code:

#define ALU_REG_ID_LIMIT SCHAR_MAX

Confirmed by adding this code in alu_setup_reg:

Code:

want = HIGHEST( want, ALU_REG_ID_NEED ); >> if(want > ALU_REG_ID_LIMIT) { >> alu_printf("Limiting registers to %u",ALU_REG_ID_LIMIT); >> } want = LOWEST( want, ALU_REG_ID_LIMIT );

Ah, so I was indeed wrong, I did think it weird that realloc somehow both succeeded and failed at once, so it was just a relic of old code, now removed

Quote:

Originally Posted by hamster_nz

Also in alu_vec.c I think this check is suspect, and most likely wrong:

Code:

>>> if ( Nsize == vec->Nsize) { return vec->block.block; }

What are you testing there, and why?

That was... an avoidance of using memmov() unnecessarily, I failed to remember to call alu_block() though, now rectified

Quote:

Originally Posted by hamster_nz

PS. Build still fails on Ubuntu

To get it to compile I had to move this header file around in alu.h:

Code:

#include <unic/limits.h> #include <errno.h> #include <uchar.h> #include <float.h> #include <ctype.h> #include <string.h> #include <stdio.h> #include <unic/stdint.h>

That was a slight error on my part, should've included unic headers after standard headers as it is supposed to prioritise existing definitions before falling back to it's own

Quote:

Originally Posted by hamster_nz

And then the link process fails with this error:

Code:

cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check /usr/bin/ld: /usr/lib/gcc/x86_64-linux-gnu/7/../../../x86_64-linux-gnu/libcheck.a(check_run.o): undefined reference to symbol 'timer_settime@@GLIBC_2.3.3' //lib/x86_64-linux-gnu/librt.so.1: error adding symbols: DSO missing from command line

The linkage error can be resolved by adding the following libraries required to support 'check': libm libpthread libsubunit librt

Currently building by running this in ./src:

Code:

gcc -o alu *.c ../tests/check_alu.c -I ../include/ -I ../cloned/unic/include/ -l check -l subunit -l rt -l pthread -lm

Are you sure subunit is needed? Doesn't even exist on my system, maybe it's specific to Ubuntu and it's forks? I'll have to investigate that when I have time, not right this second however. If you feel like trying then see if you can figure out why the division receives a divisor of 0, I've got a zoom meeting now so can't look into it myself just yet

Edit: Forgot to upload my changes, done that now

Hi! It now builds without any hacks.. :)

I had a look at the division routine. I know binary division reasonably well, but this was a little too cryptic for me to work out.

I would expect to see REM getting things subtracted off, but somehow SEG gets things subtracted.

Humm - maybe some comments would help...

Code:

N = alu_reg_data( alu, NUM ); SEG = REM; n = alu_reg_end_bit( alu, REM ); SEG.upto = SEG.from = n.bit + 1; n = alu_bit( N, NUM.from ); for ( ; alu_reg_cmp( alu, REM, VAL ) >= 0; ++bits ) { SEG.from--; if ( alu_reg_cmp( alu, SEG, VAL ) >= 0 ) { ret = alu_reg_sub( alu, SEG, VAL ); if ( ret == ENODATA ) break; alu_reg__shl( alu, NUM, TMP, bits ); *(n.ptr) |= n.mask; bits = 0; } } if ( SEG.from > REM.from ) alu_reg__shl( alu, NUM, TMP, (SEG.from - REM.from) );

Quote:

Originally Posted by hamster_nz

Hi! It now builds without any hacks.. :)

I had a look at the division routine. I know binary division reasonably well, but this was a little too cryptic for me to work out.

I would expect to see REM getting things subtracted off, but somehow SEG gets things subtracted.

Humm - maybe some comments would help...

Code:

N = alu_reg_data( alu, NUM ); SEG = REM; n = alu_reg_end_bit( alu, REM ); SEG.upto = SEG.from = n.bit + 1; n = alu_bit( N, NUM.from ); for ( ; alu_reg_cmp( alu, REM, VAL ) >= 0; ++bits ) { SEG.from--; if ( alu_reg_cmp( alu, SEG, VAL ) >= 0 ) { ret = alu_reg_sub( alu, SEG, VAL ); if ( ret == ENODATA ) break; alu_reg__shl( alu, NUM, TMP, bits ); *(n.ptr) |= n.mask; bits = 0; } } if ( SEG.from > REM.from ) alu_reg__shl( alu, NUM, TMP, (SEG.from - REM.from) );

You see how I set SEG to REM before the loop? That's because I'm defaulting the register information such as which node to REM's, I then override the bits of the node it is referring to to the bit just after the final bit set, here's a clearer example
Let's say REM is '00110010' and VAL is '00000010', SEG being set to REM's information at first will cause SEG to refer to the entirety of '00110010', overriding upto and from straight after to the bit after the final bit will make it refer to the 2nd 0 from the end, now because from is also set to that bit what SEG can actually reference is an empty value '', however we must start like that for us to then decrement the from parameter at the start of each loop thereby make SEG reference the correct bits, in this case VAL will only be less than or equal to SEG once it is decremented twice creating the comparison of '11' verses '00000010' or in decimal '3' vs '2', the original number being divided is 50 so this would create the decimal 2 of decimal 25 (the correct result of this division), the next value SEG would refer to is '010' as via SEG we already changed REM to '00010010' just as in decimal we would change the 50 to 10 which leads to 10 divided by 2 equaling 5, with SEG we would have 2 more divisions occur as we are in binary shifting along the bits as we go (or in this case once we get to the next efficient opportunity), each time because the node SEG refers to is the same as REM the result is the same type of division as we would do decimal division with a pen and paper (unless you're doing it the slow way)

Quote:

Originally Posted by awsdert

You see how I set SEG to REM before the loop? That's because I'm defaulting the register information such as which node to REM's, I then override the bits of the node it is referring to to the bit just after the final bit set, here's a clearer example
Let's say REM is '00110010' and VAL is '00000010', SEG being set to REM's information at first will cause SEG to refer to the entirety of '00110010', overriding upto and from straight after to the bit after the final bit will make it refer to the 2nd 0 from the end, now because from is also set to that bit what SEG can actually reference is an empty value '', however we must start like that for us to then decrement the from parameter at the start of each loop thereby make SEG reference the correct bits, in this case VAL will only be less than or equal to SEG once it is decremented twice creating the comparison of '11' verses '00000010' or in decimal '3' vs '2', the original number being divided is 50 so this would create the decimal 2 of decimal 25 (the correct result of this division), the next value SEG would refer to is '010' as via SEG we already changed REM to '00010010' just as in decimal we would change the 50 to 10 which leads to 10 divided by 2 equaling 5, with SEG we would have 2 more divisions occur as we are in binary shifting along the bits as we go (or in this case once we get to the next efficient opportunity), each time because the node SEG refers to is the same as REM the result is the same type of division as we would do decimal division with a pen and paper (unless you're doing it the slow way)

Oh, I see - didn't see that SEG and REM were looking at the same data. Makes sense.

I was a little bit perplexed why you were making one or two calls to alu_reg_cmp(), but now see the first one is just saying keep going until the remainder is less than the divisor. It allows you to bail out of the loop early, but I wonder how often enough of the low bits of the result will be zero to make it worthwhile.

Also, wouldn't it be more convenient to just set the absolute bit in NUM when you do the subtraction, rather than what appears to be shifting bits through the register as you loop?

I fixed the division problem, turned out the issue was split in 2 parts, 1st I noticed that alu_reg_sub() incorrectly reported ENODATA when VAL happened to have no ones aligned with a short NUM, this problem exists in alu_reg_add() also so I will be fixing that in a moment before uploading, the 2nd part of the issue was that I had mishandled a small bit of data in alu_reg_cmp() which resulted in incorrect results, fixed that and all my current tests in check_alu.c passed now, I had to remove the $(F_l) subunit from the flags given to a check build however because it would not build with it there, hamster_nz if you could tell me what system you're on I'll research a way to check for that in the dst_cc.mak and adapt to it so you no longer have to edit the flags

Quote:

Originally Posted by hamster_nz

Oh, I see - didn't see that SEG and REM were looking at the same data. Makes sense.

I was a little bit perplexed why you were making one or two calls to alu_reg_cmp(), but now see the first one is just saying keep going until the remainder is less than the divisor. It allows you to bail out of the loop early, but I wonder how often enough of the low bits of the result will be zero to make it worthwhile.

Not sure but for now it reflects the way we do it in decimal on pen and paper, just a little more complex due to the fact pc analysis and human analysis thought does not work the same way

Quote:

Originally Posted by hamster_nz

Also, wouldn't it be more convenient to just set the absolute bit in NUM when you do the subtraction, rather than what appears to be shifting bits through the register as you loop?

Maybe, however I was first aiming to have it look similar to human division so I could be clear I'm going the right direction with the division, enhancements can come later after all the requirements of a software based ALU to process integer and floating math are in place because that can be marked as stable then (ie. ready for every random John/Jane Doe to download and use)

Had to reinstall my system due to f***ing up sudo permissions, started using cppcheck and learned something new about C89, I was under the false impression that all variables had to be declared at the start of the function, corrected everything that cppcheck reported, tried finishing off the part of code that forces exponents to match, compiles fine but when running alu_check.c code I ended up with this:

Code:

make check cd ../ && make --no-print-directory check #MAKECMDGOALS=check cd mak && make -j 1 --no-print-directory -f main.mak check PRJ_LIB_NAME=alu_d Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=check_alu_d.AppImage PRJ_DST_LIB=libalu_d.so cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit_d.o -c ../src/alu_bit.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn_d.o -c ../src/alu_fpn.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int_d.o -c ../src/alu_int.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main_d.o -c ../src/alu_main.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math_d.o -c ../src/alu_math.c ../src/alu_math.c: In function ‘alu_reg_add’: ../src/alu_math.c:860:49: warning: variable ‘TMP’ set but not used [-Wunused-but-set-variable] 860 | alu_reg_t NCPY, VCPY, NEXP, NMAN, VEXP, VMAN, TMP; | ^~~ ../src/alu_math.c:860:43: warning: variable ‘VMAN’ set but not used [-Wunused-but-set-variable] 860 | alu_reg_t NCPY, VCPY, NEXP, NMAN, VEXP, VMAN, TMP; | ^~~~ ../src/alu_math.c:860:31: warning: variable ‘NMAN’ set but not used [-Wunused-but-set-variable] 860 | alu_reg_t NCPY, VCPY, NEXP, NMAN, VEXP, VMAN, TMP; | ^~~~ cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem_d.o -c ../src/alu_mem.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint_d.o -c ../src/alu_uint.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec_d.o -c ../src/alu_vec.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -shared -o ../lib/libalu_d.so ../src/alu_bit_d.o ../src/alu_fpn_d.o ../src/alu_int_d.o ../src/alu_main_d.o ../src/alu_math_d.o ../src/alu_mem_d.o ../src/alu_uint_d.o ../src/alu_vec_d.o -Wl,-rpath,../lib cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu_d.o -c ../tests/check_alu.c In file included from ../tests/check_alu.c:181: ../tests/check_alu.c:490:13: warning: ‘test_alu_reg2str’ defined but not used [-Wunused-variable] 490 | START_TEST( test_alu_reg2str ) | ^~~~~~~~~~~~~~~~ ../tests/check_alu.c:356:13: warning: ‘test_alu_op3’ defined but not used [-Wunused-variable] 356 | START_TEST( test_alu_op3 ) | ^~~~~~~~~~~~ cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check -l rt -l pthread -l m ../bin/check_alu_d.AppImage ../tests/check_alu.c:863: main() 'Running unit tests under 'check' test suite' Running suite(s): ALU ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null ... ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null 100%: Checks: 1221, Failures: 0, Errors: 0 ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null ... ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null ... ../src/alu_math.c:1174: alu_reg__shl() 'alu' was null Compilation finished successfully.

The ... is in place of a LOT of the same message, tried looking for the issue in code but couldn't find it, was gonna debug it but gede wouldn't build/install due to missing source package at AUR, got overtime to go to in few minutes so was hoping someone could debug this for me to find why I get a NULL and just post their findings for me to work from when I get back or 2mw morning (also got overtime 2mw hence morning)

Found the issue, I forgot to add a return 0; at the end of the successful scope, did that and the error went away, btw it turned out the reason gede wouldn't compile was because the dev changed domain but didn't update the scripts

*sigh* Another problem I'm not seeing the cause of, not getting the right value out of my exponent and mantissa when I do addition, here's the code snippet (from alu_math.c):

Code:

int_t alu_match_exponents ( alu_t *alu , uint_t num , uint_t val ) { if ( alu ) { int_t ret; alu_reg_t NUM, VAL, NEXP, VEXP, NMAN, VMAN; size_t nexp; alu_reg_init_floating( alu, NUM, num ); alu_reg_init_floating( alu, VAL, val ); NUM.upto = alu_Nbits(alu); VAL.upto = alu_Nbits(alu); alu_reg_init_mantissa( NUM, NMAN ); alu_reg_init_exponent( NUM, NEXP ); alu_reg_init_mantissa( VAL, VMAN ); alu_reg_init_exponent( VAL, VEXP ); ret = alu_reg_get_raw( alu, NEXP, &nexp, sizeof(size_t) ); if ( ret == 0 ) { size_t vexp, diff; (void)alu_reg_get_raw( alu, VEXP, &vexp, sizeof(size_t) ); diff = SET2IF( nexp > vexp, nexp - vexp, vexp - nexp ); if ( diff >= NMAN.upto ) { if ( nexp > vexp ) { alu_reg_clr( alu, VMAN ); alu_reg_int2int( alu, VEXP, NEXP ); } else { alu_reg_clr( alu, NMAN ); alu_reg_int2int( alu, NEXP, VEXP ); } /* We'll use this to indicate truncation, should be impossible * in this case given we are taking more space than the * developer would normally take if they use the API as * intended, this at least covers the being abused scenario */ return ERANGE; } if ( diff ) { /* We don't check for success here because prior functions we * called already got & released the register we're about to * recieve */ uint_t tmp = alu_get_reg_node( alu, 0 ); alu_reg_t TMP; alu_bit_t n; alu_reg_init_unsigned( alu, TMP, tmp ); if ( nexp > vexp ) { n = alu_bit( (void*)alu_reg_data( alu, VMAN ), 0 ); for ( ; ret == 0 && n.bit < diff; alu_bit_inc(&n) ) { ret = SET1IF( *(n.ptr) & n.mask, ENOBUFS ); } alu_reg__shr( alu, VMAN, TMP, diff ); } else { n = alu_bit( (void*)alu_reg_data( alu, NMAN ), 0 ); for ( ; ret == 0 && n.bit < diff; alu_bit_inc(&n) ) { ret = SET1IF( *(n.ptr) & n.mask, ERANGE ); } alu_reg__shr( alu, VMAN, TMP, diff ); } alu_rem_reg_node( alu, &tmp ); if ( ret ) alu_error(ret); } return ret; } alu_error(ret); return ret; } return alu_err_null_ptr("alu"); } int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = SET1IF( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); ret = alu_match_exponents( alu, cpy, tmp ); if ( ret == 0 ) { alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); ret = alu_reg_add( alu, CMAN, TMAN ); /* No chance of failure here either */ (void)alu_reg_mov( alu, NUM, CPY ); return ret; } } alu_error(ret); return ret; }

And here's a few results (top NUM is what I got, bottom num is correct result copied into NUM):

Code:

Running suite(s): ALU ../src/alu_math.c:1004: alu_reg_addition() Error 0x00000022 34 'Numerical result out of range' ../src/alu_math.c:1103: alu_reg_add() Error 0x00000022 34 'Numerical result out of range' ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 0, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0000000000000000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0011111111110000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 1, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0011111111110000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0100000000000000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 2, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0100000000000000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0100000000001000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 3, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0100000000000000000000010000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0100000000010000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 4, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0100000000010000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0100000000010100000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 5, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0100000000010000000000001000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0100000000011000000000000000000000000000000000000000000000000000

Here's the video that I'm using to understand FPN addition: Binary 7 – Floating Point Binary Addition - YouTube
And here's the one I used to understand how to set the exponent and mantissa: Floating Point Numbers - YouTube
Oh if anyone figures out how to stop the 3 extra runs of building/running when I run "make check run" I would greatly appreciate you posting it.

I'm gonna take a break, maybe fresh will help me later if noone tries or manages to figure out the cause

Still failing to manage the addition correctly, made some changes however so should be easier to understand the code as a result:

Code:

int_t alu_match_exponents_and_normalise ( alu_t *alu , uint_t num , uint_t val , uint_t tmp ) { if ( alu ) { int_t ret; alu_reg_t NUM, VAL, NEXP, VEXP, NMAN, VMAN, TMP; size_t nexp; alu_reg_init_floating( alu, NUM, num ); alu_reg_init_floating( alu, VAL, val ); alu_reg_init_unsigned( alu, TMP, tmp ); NUM.upto = alu_Nbits(alu); VAL.upto = alu_Nbits(alu); alu_reg_init_mantissa( NUM, NMAN ); alu_reg_init_exponent( NUM, NEXP ); alu_reg_init_mantissa( VAL, VMAN ); alu_reg_init_exponent( VAL, VEXP ); ret = alu_reg_get_raw( alu, NEXP, &nexp, sizeof(size_t) ); if ( ret == 0 ) { size_t vexp, diff; bool truncated = false; (void)alu_reg_get_raw( alu, VEXP, &vexp, sizeof(ssize_t) ); alu->block.fault = 0; if ( nexp > vexp ) { diff = nexp - vexp; /* Match exponent and align mantissa */ alu_reg_int2int( alu, VEXP, NEXP ); alu_reg__shr( alu, VMAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < VMAN.upto ) { void *V = alu_reg_data( alu, VAL ); alu_bit_t v = alu_bit( V, VMAN.upto - diff ); *(v.ptr) |= v.mask; /* Normalise */ diff = VMAN.upto - v.bit; alu->block.fault = 0; alu_reg__shr( alu, NMAN, TMP, diff ); truncated = (truncated || alu_errno(alu) == ERANGE); alu_reg__shr( alu, VMAN, TMP, diff ); vexp = nexp + diff; alu_reg_set_raw( alu, VEXP, &vexp, sizeof(size_t), 0 ); } } else if ( vexp > nexp ) { diff = vexp - nexp; alu_reg_int2int( alu, NEXP, VEXP ); alu_reg__shr( alu, NMAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < NMAN.upto ) { void *N = alu_reg_data( alu, NUM ); alu_bit_t n = alu_bit( N, NMAN.upto - diff ); *(n.ptr) |= n.mask; /* Normalise */ diff = NMAN.upto - n.bit; alu_reg__shr( alu, NMAN, TMP, diff ); alu->block.fault = 0; alu_reg__shr( alu, VMAN, TMP, diff ); truncated = (truncated || alu_errno(alu) == ERANGE); nexp = vexp + diff; alu_reg_set_raw( alu, NEXP, &nexp, sizeof(size_t), 0 ); } } alu->block.fault = SET1IF(truncated,ERANGE); return 0; } alu_error(ret); return ret; } return alu_err_null_ptr("alu"); } int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = SET1IF( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); ret = alu_match_exponents_and_normalise( alu, cpy, tmp, temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); ret = alu_reg_add( alu, CMAN, TMAN ); if ( ret == EOVERFLOW ) { ret = alu_reg_inc( alu, CEXP ); } /* No chance of failure here either */ (void)alu_reg_mov( alu, NUM, CPY ); alu_rem_reg_node( alu, &temp ); return SET2IF( truncated, ERANGE, ret ); } } alu_rem_reg_node( alu, &temp ); } alu_error(ret); return ret; }

Here's a link to the uploaded compile log (forums refused to understand it was a text file)
alu_check.log - Google Drive

Made some changes, fixed alu_reg_flt2flt() which was actually buggy (caught it while trying and still failing to fix FPN addition), mades an improvment to alu_print_reg() to add spaces between the different bit sections making it easier to understand what bits are part of what section (did that because I was struggling to see if it was just the mantissa that was the issue, which I just now realise I still forgot to check) created a new compile log with all the changes which in case google created a different link is here: alu_check.log - Google Drive

I re-watched the vid and realised I made a misunderstanding so ripped out the normalization code from matching the exponents, also some changes to the code calling it so here's both:

Code:

int_t alu_match_exponents ( alu_t *alu , uint_t num , uint_t val , uint_t tmp ) { if ( alu ) { int_t ret; alu_reg_t NUM, VAL, NEXP, VEXP, NMAN, VMAN, TMP; size_t nexp; alu_reg_init_floating( alu, NUM, num ); alu_reg_init_floating( alu, VAL, val ); alu_reg_init_unsigned( alu, TMP, tmp ); NUM.upto = alu_Nbits(alu); VAL.upto = alu_Nbits(alu); alu_reg_init_mantissa( NUM, NMAN ); alu_reg_init_exponent( NUM, NEXP ); alu_reg_init_mantissa( VAL, VMAN ); alu_reg_init_exponent( VAL, VEXP ); ret = alu_reg_get_raw( alu, NEXP, &nexp, sizeof(size_t) ); if ( ret == 0 ) { size_t vexp, diff; bool truncated = false; (void)alu_reg_get_raw( alu, VEXP, &vexp, sizeof(ssize_t) ); alu->block.fault = 0; if ( nexp > vexp ) { diff = nexp - vexp; /* Match exponent and align mantissa */ alu_reg_int2int( alu, VEXP, NEXP ); alu_reg__shr( alu, VMAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < VMAN.upto ) { void *V = alu_reg_data( alu, VAL ); alu_bit_t v = alu_bit( V, VMAN.upto - diff ); *(v.ptr) |= v.mask; /* Normalise */ diff = VMAN.upto - v.bit; } } else if ( vexp > nexp ) { diff = vexp - nexp; alu_reg_int2int( alu, NEXP, VEXP ); alu_reg__shr( alu, NMAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < NMAN.upto ) { void *N = alu_reg_data( alu, NUM ); alu_bit_t n = alu_bit( N, NMAN.upto - diff ); *(n.ptr) |= n.mask; } } alu->block.fault = IFTRUE(truncated,ERANGE); return 0; } alu_error(ret); return ret; } return alu_err_null_ptr("alu"); } int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = IFTRUE( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { ret = alu_match_exponents( alu, cpy, tmp, temp ); alu_rem_reg_node( alu, &temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); uint_t nodes[2]; ret = alu_get_reg_nodes( alu, nodes, 2, 0 ); if ( ret == 0 ) { alu_reg_t _CMAN, _TMAN; size_t bias, cexp; alu_reg_init_unsigned( alu, _CMAN, nodes[0] ); alu_reg_init_unsigned( alu, _TMAN, nodes[1] ); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); alu_reg_int2int( alu, _CMAN, CMAN ); alu_reg_int2int( alu, _TMAN, TMAN ); ret = alu_reg_add( alu, _CMAN, _TMAN ); switch ( ret ) { case 0: case EOVERFLOW: case ENODATA: break; default: alu_rem_reg_nodes( alu, nodes, 2 ); alu_error(ret); return ret; } n = alu_reg_end_bit( alu, _CMAN ); (void)alu_reg_get_exponent( alu, CPY, &cexp ); bias = alu_reg_get_exponent_bias( CPY ); cexp -= bias; ret = alu_reg_set_raw( alu, CEXP, &(n.bit), sizeof(size_t), 0 ); /* No chance of failure at this point */ (void)alu_reg_mov( alu, NUM, CPY ); alu_rem_reg_nodes( alu, nodes, 2 ); return EITHER( truncated, ERANGE, ret ); } } } else { ret = alu_errno(alu); } } alu_error(ret); return ret; }

Gonna grab something to eat, hopefully someone manages to spot where I went wrong, as a reminder the vids I'm using to understand FPN addition are 2 posts prior to this one

Edit: Just remembered that I thought of more appropriate names for the SET1IF and SET2IF macros, they've now been renamed to IFTRUE and EITHER respectively, they're in alu.h if you need to refresh your memory on what they do

I think I fixed it but hitting an unexpected segfault before I can check, I can't even deduce where it might be coming from because it seems some local variables relied upon at the point of the segfault have somehow been 0'd out between the call to the add function (which is right above the line the segfault occurs on) and the usage of the local variable:

Code:

ret = alu_reg_add( alu, NUM, VAL ); // between this call and the next line both NUM and VAL are somehow 0'd N = alu_reg_data( alu, NUM );

Code:

make check.run cd ../ && make --no-print-directory check.run #MAKECMDGOALS=check.run cd mak && make -j 1 --no-print-directory -f main.mak check.run PRJ_GOALS=check PRJ_LIB_NAME=alu_d Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=check_alu_d.AppImage PRJ_DST_LIB=libalu_d.so cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit_d.o -c ../src/alu_bit.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn_d.o -c ../src/alu_fpn.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int_d.o -c ../src/alu_int.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main_d.o -c ../src/alu_main.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math_d.o -c ../src/alu_math.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem_d.o -c ../src/alu_mem.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint_d.o -c ../src/alu_uint.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec_d.o -c ../src/alu_vec.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -shared -o ../lib/libalu_d.so ../src/alu_bit_d.o ../src/alu_fpn_d.o ../src/alu_int_d.o ../src/alu_main_d.o ../src/alu_math_d.o ../src/alu_mem_d.o ../src/alu_uint_d.o ../src/alu_vec_d.o -Wl,-rpath,../lib cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu_d.o -c ../tests/check_alu.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check -l rt -l pthread -l m gdb -ex run ../bin/check_alu_d.AppImage GNU gdb (GDB) 9.2 Copyright (C) 2020 Free Software Foundation, Inc. License GPLv3+: GNU GPL version 3 or later <http://gnu.org/licenses/gpl.html> This is free software: you are free to change and redistribute it. There is NO WARRANTY, to the extent permitted by law. Type "show copying" and "show warranty" for details. This GDB was configured as "x86_64-pc-linux-gnu". Type "show configuration" for configuration details. For bug reporting instructions, please see: <http://www.gnu.org/software/gdb/bugs/>. Find the GDB manual and other documentation resources online at: <http://www.gnu.org/software/gdb/documentation/>. For help, type "help". Type "apropos word" to search for commands related to "word"... Reading symbols from ../bin/check_alu_d.AppImage... Starting program: /mnt/MEDIA/HOME/github/alu/bin/check_alu_d.AppImage [Thread debugging using libthread_db enabled] Using host libthread_db library "/usr/lib/libthread_db.so.1". Running suite(s): ALU Program received signal SIGSEGV, Segmentation fault. 0x0000555555562f24 in test_alu_reg_add_floating_fn (_i=0) at ../tests/check_alu.c:958 958 N = alu_reg_data( alu, NUM ); (gdb) quit A debugging session is active. Inferior 1 [process 14337] will be killed. Quit anyway? (y or n) [answered Y; input not from terminal] rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o Compilation finished successfully.

I've tried debugging but I'm honestly lost on where to find the bug, if anyone has any ideas from looking at the project code I would appreciate you mentioning it even if it turns out to be a dead end.

Can't debug what I can't build:

Code:

... cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/test_alu.o -c ../tests/test_alu.c ../tests/test_alu.c: In function ‘reg_compare’: ../tests/test_alu.c:27:2: warning: implicit declaration of function ‘alu_reg_init’; did you mean ‘alu_reg_inc’? [-Wimplicit-function-declaration] alu_reg_init( alu, NUM, nodes[0], info ); ^~~~~~~~~~~~ alu_reg_inc ../tests/test_alu.c:32:2: warning: ‘NUM.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, NUM.node, _num ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ../tests/test_alu.c:33:2: warning: ‘VAL.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, VAL.node, _val ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ../tests/test_alu.c: In function ‘modify’: ../tests/test_alu.c:83:2: warning: ‘VAL.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, VAL.node, _val ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ cc -D NDEBUG -O3 -fPIE -L ../lib -o ../bin/test_alu.AppImage ../tests/test_alu.o -Wl,-rpath,../lib -l alu ../tests/test_alu.o: In function `reg_compare': test_alu.c:(.text+0x173): undefined reference to `alu_reg_init' test_alu.c:(.text+0x1a0): undefined reference to `alu_reg_init' ../tests/test_alu.o: In function `modify': test_alu.c:(.text+0x423): undefined reference to `alu_reg_init' test_alu.c:(.text+0x450): undefined reference to `alu_reg_init' test_alu.c:(.text+0x47f): undefined reference to `alu_reg_init' ../tests/test_alu.o:test_alu.c:(.text+0x2271): more undefined references to `alu_reg_init' follow collect2: error: ld returned 1 exit status main.mak:122: recipe for target 'test_alu.AppImage' failed make[1]: *** [test_alu.AppImage] Error 1 rm ../src/alu_math.o ../src/alu_bit.o ../src/alu_fpn.o ../tests/test_alu.o ../src/alu_uint.o ../src/alu_vec.o ../src/alu_int.o ../src/alu_mem.o ../src/alu_main.o makefile:9: recipe for target 'check' failed make: *** [check] Error 2

(This was a fresh clone of the repo)

Quote:

Originally Posted by hamster_nz

Can't debug what I can't build:

Code:

... cc -D NDEBUG -O3 -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/test_alu.o -c ../tests/test_alu.c ../tests/test_alu.c: In function ‘reg_compare’: ../tests/test_alu.c:27:2: warning: implicit declaration of function ‘alu_reg_init’; did you mean ‘alu_reg_inc’? [-Wimplicit-function-declaration] alu_reg_init( alu, NUM, nodes[0], info ); ^~~~~~~~~~~~ alu_reg_inc ../tests/test_alu.c:32:2: warning: ‘NUM.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, NUM.node, _num ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ../tests/test_alu.c:33:2: warning: ‘VAL.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, VAL.node, _val ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ../tests/test_alu.c: In function ‘modify’: ../tests/test_alu.c:83:2: warning: ‘VAL.node’ may be used uninitialized in this function [-Wmaybe-uninitialized] alu_int_set_raw( alu, VAL.node, _val ); ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ cc -D NDEBUG -O3 -fPIE -L ../lib -o ../bin/test_alu.AppImage ../tests/test_alu.o -Wl,-rpath,../lib -l alu ../tests/test_alu.o: In function `reg_compare': test_alu.c:(.text+0x173): undefined reference to `alu_reg_init' test_alu.c:(.text+0x1a0): undefined reference to `alu_reg_init' ../tests/test_alu.o: In function `modify': test_alu.c:(.text+0x423): undefined reference to `alu_reg_init' test_alu.c:(.text+0x450): undefined reference to `alu_reg_init' test_alu.c:(.text+0x47f): undefined reference to `alu_reg_init' ../tests/test_alu.o:test_alu.c:(.text+0x2271): more undefined references to `alu_reg_init' follow collect2: error: ld returned 1 exit status main.mak:122: recipe for target 'test_alu.AppImage' failed make[1]: *** [test_alu.AppImage] Error 1 rm ../src/alu_math.o ../src/alu_bit.o ../src/alu_fpn.o ../tests/test_alu.o ../src/alu_uint.o ../src/alu_vec.o ../src/alu_int.o ../src/alu_mem.o ../src/alu_main.o makefile:9: recipe for target 'check' failed make: *** [check] Error 2

(This was a fresh clone of the repo)

You're building the wrong one for the bug I experienced, you have however reminded me that I need to go fix that file again after the minor API change, use "make check" or if you have gede installed then "make check.gede" My only way of stopping the repeat builds was to just append the additional targets to each other as one target

Edit: File is fixed now, along with a few extra bugs I noticed after running it

I was making 'check' - see line 31.

You're in luck - Harry Potter is on TV. Oh no, not again.... will debug while I watch.

Got it to build using:

Code:

gcc -o alu *.c ../tests/check_alu.c -Wall -pedantic -I ../include -I ../cloned/unic/include -l check -lm -lsubunit -lpthread -lrt -g

And verified that it segfaulted.

Spent a while looking at what is going on around line 1152 in math.c, where it dies.

v is declared on line 1054 of alu_math.c

Code:

alu_bit_t n, v

v is used on line 1152

Code:

*(v.ptr) |= v.mask;

But v isn't initialised till line 1195:

Code:

v = alu_bit( part, VAL.from );

It looks to me that 'v' is just holding junk from the stack. Can verify that.

After 'v' is declared, I set it to 0xFFs with:

Code:

memset(&v,255,sizeof(v));

Then in gdb:

Code:

... Running suite(s): ALU Program received signal SIGSEGV, Segmentation fault. 0x000055555555dfec in alu_reg_addition (alu=0x7fffffffde20, NUM=..., VAL=..., cpy=10, tmp=11) at alu_math.c:1153 1153 *(v.ptr) |= v.mask; (gdb) print v $1 = {seg = 18446744073709551615, bit = 18446744073709551615, pos = 18446744073709551615, ptr = 0xffffffffffffffff, mask = 18446744073709551615} (gdb) printf "%lx", v.seg ffffffffffffffff(gdb) printf "%lx\n", v.seg ffffffffffffffff (gdb) printf "%lx\n", v.bit ffffffffffffffff (gdb) printf "%lx\n", v.pos ffffffffffffffff (gdb) printf "%lx\n", v.ptr

Yep - using uninitialized values.

Not bothering to analyze the code, and just looking at context, I think

Code:

n = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , exp ); *(v.ptr) |= v.mask; <<<< LINE 1152

should be:

Code:

n = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , exp ); *(n.ptr) |= n.mask; <<<< LINE 1152

That's an hour of debugging... 30 minutes per character?

Quote:

Originally Posted by hamster_nz

Spent a while looking at what is going on around line 1152 in math.c, where it dies.

v is declared on line 1054 of alu_math.c

Still looking through your post but are you sure you've got up to date files?
When I look at that line with what I have uploaded all I see is this:

Code:

}

Quote:

Originally Posted by hamster_nz

You're in luck - Harry Potter is on TV. Oh no, not again.... will debug while I watch.

Got it to build using:

Code:

gcc -o alu *.c ../tests/check_alu.c -Wall -pedantic -I ../include -I ../cloned/unic/include -l check -lm -lsubunit -lpthread -lrt -g

And verified that it segfaulted.

Spent a while looking at what is going on around line 1152 in math.c, where it dies.

v is declared on line 1054 of alu_math.c

Code:

alu_bit_t n, v

v is used on line 1152

Code:

*(v.ptr) |= v.mask;

But v isn't initialised till line 1195:

Code:

v = alu_bit( part, VAL.from );

It looks to me that 'v' is just holding junk from the stack. Can verify that.

After 'v' is declared, I set it to 0xFFs with:

Code:

memset(&v,255,sizeof(v));

Then in gdb:

Code:

... Running suite(s): ALU Program received signal SIGSEGV, Segmentation fault. 0x000055555555dfec in alu_reg_addition (alu=0x7fffffffde20, NUM=..., VAL=..., cpy=10, tmp=11) at alu_math.c:1153 1153 *(v.ptr) |= v.mask; (gdb) print v $1 = {seg = 18446744073709551615, bit = 18446744073709551615, pos = 18446744073709551615, ptr = 0xffffffffffffffff, mask = 18446744073709551615} (gdb) printf "%lx", v.seg ffffffffffffffff(gdb) printf "%lx\n", v.seg ffffffffffffffff (gdb) printf "%lx\n", v.bit ffffffffffffffff (gdb) printf "%lx\n", v.pos ffffffffffffffff (gdb) printf "%lx\n", v.ptr

Yep - using uninitialized values.

Not bothering to analyze the code, and just looking at context, I think

Code:

n = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , exp ); *(v.ptr) |= v.mask; <<<< LINE 1152

should be:

Code:

n = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , exp ); *(n.ptr) |= n.mask; <<<< LINE 1152

That's an hour of debugging... 30 minutes per character?

Thank you :) Wrong fix but helped me see what was wrong, instead of v being filled n got filled, n was supposed to only refer to either NUM or CPY (depends on where it is used), likewise v is only supposed to refer to VAL or TMP, sadly FPN addition is still broken

I finally spotted one of the reasons why my FPN math is failing, just can't spot the cause of that reason, basically the mantissa is not far enough to the right by the time the result is given, I've hand picked a few of the results to show what I mean:

Code:

../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 45, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 0497 00111110001 1000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 1028 10000000100 0111000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 46, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 0497 00111110001 1100000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 1028 10000000100 0111100000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 47, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 0498 00111110010 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 1028 10000000100 1000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 48, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 0498 00111110010 0010000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 1028 10000000100 1000100000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 49, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 0498 00111110010 0100000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 1028 10000000100 1001000000000000000000000000000000000000000000000000

The 4 digit value between the sign bit and the exponent bits is just the exponent in decimal prepended with 0's for alignment, as a reminder the top NUM is the result of my code while the bottom NUM is the result of
hardware addition, the code I used for those results is here, if anyone spots a potential cause I would greatly appreciate you mentioning it even if it turns out to be a wild goose chase because I may catch something else along the way

Code:

int_t alu_match_exponents ( alu_t *alu , uint_t num , uint_t val , uint_t tmp ) { if ( alu ) { int_t ret; alu_reg_t NUM, VAL, MAN, TMP; size_t nexp; alu_reg_init_floating( alu, NUM, num ); alu_reg_init_floating( alu, VAL, val ); alu_reg_init_unsigned( alu, TMP, tmp ); NUM.upto = alu_Nbits(alu); VAL.upto = alu_Nbits(alu); ret = alu_reg_get_exponent( alu, NUM, &nexp ); if ( ret == 0 ) { size_t vexp, diff; bool truncated = false; (void)alu_reg_get_exponent( alu, VAL, &vexp ); if ( nexp > vexp ) { if ( vexp ) { diff = nexp - vexp; alu_reg_init_mantissa( VAL, MAN ); /* Match exponent and align mantissa */ (void)alu_reg_set_exponent( alu, VAL, nexp ); alu->block.fault = 0; alu_reg__shr( alu, MAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < MAN.upto ) { void *V = alu_reg_data( alu, VAL ); alu_bit_t v = alu_bit( V, MAN.upto - diff ); *(v.ptr) |= v.mask; } } } else if ( vexp > nexp ) { if ( nexp ) { diff = vexp - nexp; alu_reg_init_mantissa( NUM, MAN ); (void)alu_reg_set_exponent( alu, NUM, vexp ); alu->block.fault = 0; alu_reg__shr( alu, MAN, TMP, diff ); truncated = (alu_errno(alu) == ERANGE); /* Insert assumed bit back into position */ if ( diff < MAN.upto ) { void *N = alu_reg_data( alu, NUM ); alu_bit_t n = alu_bit( N, MAN.upto - diff ); *(n.ptr) |= n.mask; } } } alu->block.fault = IFTRUE(truncated,ERANGE); return 0; } alu_error(ret); return ret; } return alu_err_null_ptr("alu"); } int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = IFTRUE( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { ret = alu_match_exponents( alu, cpy, tmp, temp ); alu_rem_reg_node( alu, &temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); uint_t nodes[2]; ret = alu_get_reg_nodes( alu, nodes, 2, 0 ); if ( ret == 0 ) { do { alu_reg_t _CMAN, _TMAN; size_t bias, exp; alu_reg_init_unsigned( alu, _CMAN, nodes[0] ); alu_reg_init_unsigned( alu, _TMAN, nodes[1] ); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); alu_reg_int2int( alu, _CMAN, CMAN ); alu_reg_int2int( alu, _TMAN, TMAN ); (void)alu_reg_get_exponent( alu, CPY, &exp ); bias = alu_reg_get_exponent_bias( CPY ); if ( exp ) { exp -= bias; if ( (ssize_t)exp < 0 ) { exp = -exp; } n = alu_bit ( (void*)alu_reg_data( alu, _CMAN ) , exp ); *(n.ptr) |= n.mask; v = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , exp ); *(v.ptr) |= v.mask; } /* Not possible to get an EOVERFLOW from these */ ret = alu_reg_add( alu, _CMAN, _TMAN ); if ( ret != 0 && ret != ENODATA ) break; n = alu_reg_end_bit( alu, _CMAN ); if ( n.bit || *(n.ptr) & n.mask ) { exp = n.bit + bias; ret = alu_reg_set_exponent( alu, CPY, exp ); if ( ret ) break; _CMAN.upto = n.bit - 1; pos = LOWEST( CMAN.upto, _CMAN.upto ); _CMAN.from = _CMAN.upto - pos; CMAN.from = CMAN.upto - pos; (void)alu_reg_int2int( alu, CMAN, _CMAN ); } ret = alu_reg_mov( alu, NUM, CPY ); if ( ret ) break; alu_rem_reg_nodes( alu, nodes, 2 ); return EITHER( truncated, ERANGE, ret ); } while (0); alu_rem_reg_nodes( alu, nodes, 2 ); alu_error(ret); return ret; } } } else { ret = alu_errno(alu); } } alu_error(ret); return ret; }

Managed to fix the mantissa, now it just the exponent that is the problem, I welcome any ideas there:

Code:

int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = IFTRUE( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { alu_puts( "Addition details" ); alu_puts( "================" ); #if 0 alu_print_reg( alu, CPY, 0, 1 ); alu_print_reg( alu, TMP, 0, 1 ); #endif ret = alu_match_exponents( alu, cpy, tmp, temp ); alu_rem_reg_node( alu, &temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); uint_t nodes[2]; ret = alu_get_reg_nodes( alu, nodes, 2, 0 ); if ( ret == 0 ) { do { alu_reg_t _CMAN, _TMAN; size_t bias, exp; alu_reg_init_unsigned( alu, _CMAN, nodes[0] ); alu_reg_init_unsigned( alu, _TMAN, nodes[1] ); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); _CMAN.upto = CMAN.upto + 2; _TMAN.upto = TMAN.upto + 2; alu_reg_int2int( alu, _CMAN, CMAN ); alu_reg_int2int( alu, _TMAN, TMAN ); (void)alu_reg_get_exponent( alu, CPY, &exp ); bias = alu_reg_get_exponent_bias( CPY ); if ( exp && exp != bias ) { exp -= bias; n = alu_bit ( (void*)alu_reg_data( alu, _CMAN ) , CMAN.upto ); *(n.ptr) |= n.mask; v = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , TMAN.upto ); *(v.ptr) |= v.mask; } #if 0 /* Not possible to get an EOVERFLOW from these */ alu_print_reg( alu, _CMAN, 0, 1 ); alu_print_reg( alu, _TMAN, 0, 1 ); #endif ret = alu_reg_add( alu, _CMAN, _TMAN ); if ( ret != 0 && ret != ENODATA ) break; n = alu_reg_end_bit( alu, _CMAN ); if ( n.bit || *(n.ptr) & n.mask ) { exp = n.bit + bias; ret = alu_reg_set_exponent( alu, CPY, exp ); if ( ret ) break; _CMAN.upto = n.bit - 1; pos = LOWEST( CMAN.upto, _CMAN.upto ); _CMAN.from = _CMAN.upto - pos; CMAN.from = CMAN.upto - pos; (void)alu_reg_int2int( alu, CMAN, _CMAN ); } ret = alu_reg_mov( alu, NUM, CPY ); if ( ret ) break; alu_rem_reg_nodes( alu, nodes, 2 ); return EITHER( truncated, ERANGE, ret ); } while (0); alu_rem_reg_nodes( alu, nodes, 2 ); alu_error(ret); return ret; } } } else { ret = alu_errno(alu); } } alu_error(ret); return ret; }

I know there are probably some edge cases but I will work on that once I have general arithmetic working properly

Gotten a heck of a lot closer, realised I forgot to take the position of the mantissa bits into account

Code:

int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = IFTRUE( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { ret = alu_match_exponents( alu, cpy, tmp, temp ); alu_rem_reg_node( alu, &temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); uint_t nodes[2]; ret = alu_get_reg_nodes( alu, nodes, 2, 0 ); if ( ret == 0 ) { do { alu_reg_t _CMAN, _TMAN; size_t bias, _exp; ssize_t exp; alu_reg_init_unsigned( alu, _CMAN, nodes[0] ); alu_reg_init_unsigned( alu, _TMAN, nodes[1] ); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); _CMAN.upto = CMAN.upto + 2; _TMAN.upto = TMAN.upto + 2; alu_reg_int2int( alu, _CMAN, CMAN ); alu_reg_int2int( alu, _TMAN, TMAN ); (void)alu_reg_get_exponent( alu, CPY, &_exp ); bias = alu_reg_get_exponent_bias( CPY ); if ( _exp && _exp != bias ) { _exp -= bias; n = alu_bit ( (void*)alu_reg_data( alu, _CMAN ) , CMAN.upto ); *(n.ptr) |= n.mask; v = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , TMAN.upto ); *(v.ptr) |= v.mask; } else _exp = 0; exp = _exp; ret = alu_reg_add( alu, _CMAN, _TMAN ); if ( ret != 0 && ret != ENODATA ) break; n = alu_reg_end_bit( alu, _CMAN ); part = alu_reg_data( alu, _CMAN ); for ( v = alu_bit( part, 0 ) ; v.bit < n.bit && !(*(v.ptr) & v.mask) ; alu_bit_inc(&v) ); if ( n.bit || *(n.ptr) & n.mask ) { _exp = n.bit - v.bit; ret = alu_reg_set_exponent( alu, CPY, bias + _exp ); if ( ret ) break; _CMAN.upto = n.bit - 1; pos = LOWEST( CMAN.upto, _CMAN.upto ); _CMAN.from = _CMAN.upto - pos; CMAN.from = CMAN.upto - pos; (void)alu_reg_int2int( alu, CMAN, _CMAN ); } else { ret = alu_reg_set_exponent( alu, CPY, (ssize_t)bias + exp ); if ( ret ) break; } ret = alu_reg_mov( alu, NUM, CPY ); if ( ret ) break; alu_rem_reg_nodes( alu, nodes, 2 ); return EITHER( truncated, ERANGE, ret ); } while (0); alu_rem_reg_nodes( alu, nodes, 2 ); alu_error(ret); return ret; } } } else { ret = alu_errno(alu); } } alu_error(ret); return ret; }

This is the closest I've gotten:

Code:

make check.run ... gdb -ex run ../bin/check_alu_d.AppImage GNU gdb (GDB) 9.2 ... Reading symbols from ../bin/check_alu_d.AppImage... Starting program: ~/alu/bin/check_alu_d.AppImage [Thread debugging using libthread_db enabled] Using host libthread_db library "/usr/lib/libthread_db.so.1". Running suite(s): ALU ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 0, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +0001 10000000000 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0000 01111111111 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 1, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +1024 11111111111 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0001 10000000000 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 3, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +0001 10000000000 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0002 10000000001 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 7, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +0002 10000000001 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0003 10000000010 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 15, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +0003 10000000010 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0004 10000000011 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:967: test_alu_reg_add_floating_fn() _num = 31, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:978: test_alu_reg_add_floating_fn() NUM = 0 +0004 10000000011 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:980: test_alu_reg_add_floating_fn() NUM = 0 +0005 10000000100 0000000000000000000000000000000000000000000000000000 99%: Checks: 1584, Failures: 6, Errors: 0 ../tests/check_alu.c:982:F:Core:test_alu_reg_add_floating:0: Assertion '1 == 0' failed ... ../tests/check_alu.c:982:F:Core:test_alu_reg_add_floating:31: Assertion '1 == 0' failed ==9545==LeakSanitizer has encountered a fatal error. ==9545==HINT: For debugging, try setting environment variable LSAN_OPTIONS=verbosity=1:log_threads=1 ==9545==HINT: LeakSanitizer does not work under ptrace (strace, gdb, etc) [Inferior 1 (process 9545) exited with code 01] (gdb) quit rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o Compilation finished successfully.

With this code:

Code:

int_t alu_reg_addition( alu_t *alu , alu_reg_t NUM , alu_reg_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; bool carry = false, changed = false; alu_bit_t n, v; size_t pos; void *part; alu_reg_t CPY, CEXP, CMAN, TEXP, TMAN, TMP; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); ret = IFTRUE( !NUM.node || !VAL.node, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); return ret; } if ( alu_reg_floating( VAL ) ) { alu_reg_init_floating( alu, TMP, tmp ); TMP.upto = alu_Nbits(alu); /* VAL is supposed to be unchanged so use VCPY instead */ ret = alu_reg_mov( alu, TMP, VAL ); if ( ret == 0 ) { alu_reg_init_floating( alu, CPY, cpy ); CPY.upto = alu_Nbits(alu); /* Need NUM to be unchanged so can restore details later, * having both floats the same size also makes math easier, * also no chance of failure here as the previous move * succeeded in getting the same temporary registers this * one will be looking for */ (void)alu_reg_mov( alu, CPY, NUM ); uint_t temp = alu_get_reg_node( alu, 0 ); if ( temp ) { ret = alu_match_exponents( alu, cpy, tmp, temp ); alu_rem_reg_node( alu, &temp ); if ( ret == 0 ) { bool truncated = (alu_errno(alu) == ERANGE); uint_t nodes[2]; ret = alu_get_reg_nodes( alu, nodes, 2, 0 ); if ( ret == 0 ) { do { alu_reg_t _CMAN, _TMAN; size_t bias, _exp; ssize_t exp; alu_reg_init_unsigned( alu, _CMAN, nodes[0] ); alu_reg_init_unsigned( alu, _TMAN, nodes[1] ); alu_reg_init_exponent( CPY, CEXP ); alu_reg_init_exponent( TMP, TEXP ); alu_reg_init_mantissa( CPY, CMAN ); alu_reg_init_mantissa( TMP, TMAN ); _CMAN.upto = CMAN.upto + 2; _TMAN.upto = TMAN.upto + 2; alu_reg_int2int( alu, _CMAN, CMAN ); alu_reg_int2int( alu, _TMAN, TMAN ); (void)alu_reg_get_exponent( alu, CPY, &_exp ); bias = alu_reg_get_exponent_bias( CPY ); if ( _exp && _exp != bias ) { _exp -= bias; n = alu_bit ( (void*)alu_reg_data( alu, _CMAN ) , CMAN.upto ); *(n.ptr) |= n.mask; v = alu_bit ( (void*)alu_reg_data( alu, _TMAN ) , TMAN.upto ); *(v.ptr) |= v.mask; } exp = _exp; ret = alu_reg_add( alu, _CMAN, _TMAN ); if ( ret == ENODATA ) { ++exp; ret = 0; } if ( ret != 0 && ret != ENODATA ) break; n = alu_reg_end_bit( alu, _CMAN ); part = alu_reg_data( alu, _CMAN ); for ( v = alu_bit( part, 0 ) ; v.bit < n.bit && !(*(v.ptr) & v.mask) ; alu_bit_inc(&v) ); ret = alu_reg_set_exponent( alu, CPY, bias + exp ); if ( ret ) break; (void)alu_reg_int2int( alu, CMAN, _CMAN ); ret = alu_reg_mov( alu, NUM, CPY ); if ( ret ) break; alu_rem_reg_nodes( alu, nodes, 2 ); return EITHER( truncated, ERANGE, ret ); } while (0); alu_rem_reg_nodes( alu, nodes, 2 ); alu_error(ret); return ret; } } } else { ret = alu_errno(alu); } } alu_error(ret); return ret; }

I'm gonna take a break, hopefully someone finds the fault before I get back to trying

If you're periodically running into undefined behavior, valgrind might be able to identify cases you haven't noticed.

Ruling out these cases might be helpful.

If I was in your position I would really start looking how actual floating point H/W does addition. There are plenty of papers out there:

https://www.ijert.org/research/desig...TV2IS70837.pdf

https://core.ac.uk/download/pdf/190942867.pdf

These sorts of problems tend to need to be written once, and rewritten twice (or 'refactored' if you don't like "rewritten" as a term).

- The first write is to work out what needs to happen, and it usually is broken and littered with errors in corner cases.

- The first rewrite is to make it actually work correctly, but is poorly performing and poorly structured.

- The second rewrite uses are the things learnt along the way to write a clean and efficient implementation.

You can sometimes jump the first couple of attempts if you read a few published papers, which will point out the corner cases and traps to you.

Quote:

Originally Posted by hamster_nz

If I was in your position I would really start looking how actual floating point H/W does addition. There are plenty of papers out there:

https://www.ijert.org/research/desig...TV2IS70837.pdf

https://core.ac.uk/download/pdf/190942867.pdf

These sorts of problems tend to need to be written once, and rewritten twice (or 'refactored' if you don't like "rewritten" as a term).

- The first write is to work out what needs to happen, and it usually is broken and littered with errors in corner cases.

- The first rewrite is to make it actually work correctly, but is poorly performing and poorly structured.

- The second rewrite uses are the things learnt along the way to write a clean and efficient implementation.

You can sometimes jump the first couple of attempts if you read a few published papers, which will point out the corner cases and traps to you.

In this case I need to first fully understand what needs to happen, I find that I tend to understand stuff like this better by actually going through the trial and error stuff, judging by the fact I'm almost there with the results I'd say I now have a mostly full understanding of FPN addition, I'll be adding to that understanding once I get the remaining results correct, anyways now that I'm here again JonA since you brought it up (and reminded me of it's existence) do you know anything about this line:

Code:

==2387==ASan runtime does not come first in initial library list; you should either link runtime to your application or manually preload it with LD_PRELOAD.

from this output?

Code:

make check.valgrind cd ../ && make --no-print-directory check.valgrind #MAKECMDGOALS=check.valgrind cd mak && make -j 1 --no-print-directory -f main.mak check.valgrind PRJ_GOALS= check PRJ_LIB_NAME=alu_d Checking 3rd Party libraries are upto date cd '../cloned/unic' && git fetch && git pull Finished checking PRJ_DST_BIN=check_alu_d.AppImage PRJ_DST_LIB=libalu_d.so cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_bit_d.o -c ../src/alu_bit.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_fpn_d.o -c ../src/alu_fpn.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_int_d.o -c ../src/alu_int.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_main_d.o -c ../src/alu_main.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_math_d.o -c ../src/alu_math.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_mem_d.o -c ../src/alu_mem.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_uint_d.o -c ../src/alu_uint.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../src/alu_vec_d.o -c ../src/alu_vec.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -shared -o ../lib/libalu_d.so ../src/alu_bit_d.o ../src/alu_fpn_d.o ../src/alu_int_d.o ../src/alu_main_d.o ../src/alu_math_d.o ../src/alu_mem_d.o ../src/alu_uint_d.o ../src/alu_vec_d.o -Wl,-rpath,../lib cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIC -Wall -Wextra -pedantic -I ../cloned/unic/include -I ../include -D UNIC_FALLBACK -o ../tests/check_alu_d.o -c ../tests/check_alu.c cc -ggdb -D _DEBUG -O0 -fsanitize=address -fPIE -L ../lib -o ../bin/check_alu_d.AppImage ../tests/check_alu_d.o -Wl,-rpath,../lib -l alu_d -l check -l rt -l pthread -l m valgrind ../bin/check_alu_d.AppImage ==2387== Memcheck, a memory error detector ==2387== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al. ==2387== Using Valgrind-3.16.1 and LibVEX; rerun with -h for copyright info ==2387== Command: ../bin/check_alu_d.AppImage ==2387== ==2387==ASan runtime does not come first in initial library list; you should either link runtime to your application or manually preload it with LD_PRELOAD. ==2387== ==2387== HEAP SUMMARY: ==2387== in use at exit: 0 bytes in 0 blocks ==2387== total heap usage: 0 allocs, 0 frees, 0 bytes allocated ==2387== ==2387== All heap blocks were freed -- no leaks are possible ==2387== ==2387== For lists of detected and suppressed errors, rerun with: -s ==2387== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0) rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o make[2]: *** [main.mak:104: check.valgrind] Error 1 make[1]: *** [makefile:10: check.valgrind] Error 2 make: *** [makefile:4: check.valgrind] Error 2 Compilation failed.

I usually find that googling an acronym gives me everything but what I'm looking for so it would be helpful to be pointed in the right direction.

Since I was drawing a blank on how to fix the exponent I decided to move as much core code into ptr handling variants as possible, now I've a segfault and I'm drawing a blank on the how there also, maybe some fresh eyes will help:

Code:

int_t alup__shr( alup_t _NUM, void *_tmp, size_t by ) { int_t ret = 0; if ( by ) { alup_t _TMP; /* Mantissa will use same bits but exponent will be lesser */ if ( alup_floating( _NUM ) ) { alup_t _EXP; alup_init_exponent( _NUM, _EXP ); alup_init_unsigned( _TMP, &by, sizeof(size_t) ); return alup_sub_int2int( _EXP, _TMP ); } else { alub_t n, v; bool_t neg = alup_below0( _NUM ); size_t diff = _NUM.upto - _NUM.from; size_t size = (diff / UNIC_CHAR_BIT) + !!(diff % UNIC_CHAR_BIT); if ( by >= diff ) { alup_set( _NUM, neg ); return 0; } alup_init_unsigned( _TMP, _tmp, size ); /* We have the ptr so might as well */ ret = alup_mov_int2int( _TMP, _NUM ); if ( ret ) { alu_error(ret); return ret; } n = alub( _NUM.data, _NUM.from ); v = alub( _tmp, 0 ); while ( by ) { --by; alub_dec(&n); ret = EITHER( *(n.ptr) & n.mask, ERANGE, ret ); // This line is where the segfault occurs

In meantime I'm gonna get something to eat, hopefully someone can find the root cause while I'm taking a break, in case no one's looked at the recent upload messages on the github page I've switch to shorter names for the internal stuff
alu_bit_* to alub_*
alu_reg_* to alur_*
alu_ptr_* to alup_*

In general the order of calls looks roughly like this: alu_* > alur_* > alup_* > alub_*

Fixed that segfault, turned I had poorly initialised a few variables in the process of moving core code, anyways I got closer to the correct behavior of FPN, addition, turned out I had to check the prior states of the exponents before deciding to add the assumed bit, also had to shorten the resulting mantissa length by 1 to ensure I got the overflow error upon those 2 bits being added, I used that error to detect when the final exponent should be incremented, now I've just got what appears to be an edge case and a buggy rotate right bitwise (either that or the width given to it is wrong, haven't seen possible causes of either yet)

Code:

make check.run ... Running suite(s): ALU ../tests/check_alu.c:966: test_alur_add_floating_fn() _num = 1, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:977: test_alur_add_floating_fn() NUM = 0 +1023 11111111110 0000000000000000000000000000000000000000000000000000 ../tests/check_alu.c:979: test_alur_add_floating_fn() NUM = 0 +0001 10000000000 0000000000000000000000000000000000000000000000000000 99%: Checks: 1584, Failures: 1, Errors: 0 ../tests/check_alu.c:981:F:Core:test_alur_add_floating:1: Assertion '1 == 0' failed ==11026==LeakSanitizer has encountered a fatal error. ==11026==HINT: For debugging, try setting environment variable LSAN_OPTIONS=verbosity=1:log_threads=1 ==11026==HINT: LeakSanitizer does not work under ptrace (strace, gdb, etc) [Inferior 1 (process 11026) exited with code 01] (gdb) quit rm ../src/alu_int_d.o ../src/alu_math_d.o ../tests/check_alu_d.o ../src/alu_main_d.o ../src/alu_uint_d.o ../src/alu_fpn_d.o ../src/alu_bit_d.o ../src/alu_mem_d.o ../src/alu_vec_d.o Compilation finished successfully.

I'll post code for the right shift in a minute, forgot to make alur__ror() rely on alup__ror()

Edit: Apparently it was the alur__ror() that was buggy, dunno what I did there but making it rely on alup__ror() instead got rid of the right shift errors so I'll ignore that one. I've replaced the above output with the fresh output, as you can see it is only 1 addition left that is resulting in the incorrect exponent, since I'm once again drawing a blank I'll leave it at that after uploading the change I just made, hopefully either I or someone else gets an idea for fixing that while I'm moving more code into the alup_* functions

I find it interesting that you don't see compile errors when using uninitialized variables, even though warnings are turned on.

I haven't bothered investigating why that would be... can you think of any reason?

Quote:

Originally Posted by hamster_nz

I find it interesting that you don't see compile errors when using uninitialized variables, even though warnings are turned on.

I haven't bothered investigating why that would be... can you think of any reason?

Because I initialise them before I use them, it only kicks up a fuss when there is no sign of it being initialised at all before the attempt to use the information it has

Here's an example:

Code:

int ret; return ret; // Error flagged here

Code:

int ret; foo(&ret); return ret; // No error because foo is now seen as responsible for initialisation

Edit: Another example:

Code:

int ret; ret = foo(); return ret; // No error because it was initialised with the result of foo()

I've managed to greatly simplify the FPN addition code, still same bug but now the code is far easier to read, it seems adding that extra variable to the shift functions was the greatest mistake I've made in the ALU project.
A reminder of the bug:

Code:

make check.run ... Using host libthread_db library "/usr/lib/libthread_db.so.1". Running suite(s): ALU ../src/alur.c:366: alur_add() Error 0x00000022 34 'Numerical result out of range' ../tests/check_alu.c:1037: test_alur_add_floating_fn() _num = 1, _val = 1, (EXP.upto = 63) - (EXP.from = 52) = 11, (MAN.upto = 52) - (MAN.from = 0) = 52 ../tests/check_alu.c:1048: test_alur_add_floating_fn() NUM = 0 +0000 01111111111 0000000000000000000000000000000000000000000000000000 // Incorrect result from software ../tests/check_alu.c:1050: test_alur_add_floating_fn() NUM = 0 +0001 10000000000 0000000000000000000000000000000000000000000000000000 // Correct result from hardware 99%: Checks: 1584, Failures: 1, Errors: 0 ... Compilation finished successfully.

The addition part:

Code:

int_t alur__add( alu_t *alu , alur_t NUM , alur_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; //alub_t n, v; alup_t _NUM, _VAL; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); cpy %= alu_used(alu); tmp %= alu_used(alu); ret = IFTRUE( !NUM.node || !VAL.node || !cpy || !tmp, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); if ( !cpy ) alu_puts( "cpy was 0!" ); if ( !tmp ) alu_puts( "tmp was 0!" ); return ret; } alup_init_register( alu, _NUM, NUM ); alup_init_register( alu, _VAL, VAL ); if ( alur_floating( NUM ) || alur_floating( VAL ) ) { alup_t _CPY, _TMP, _CMAN, _TMAN; size_t exp;//, cexp, texp;//, bias; bool_t truncated = false; alup_init_floating( _CPY, alu_data(alu, cpy), alu_Nsize(alu) ); alup_init_floating( _TMP, alu_data(alu, tmp), alu_Nsize(alu) ); alup_init_mantissa( _CPY, _CMAN ); alup_init_mantissa( _TMP, _TMAN ); alup_mov( _CPY, _NUM ); alup_mov( _TMP, _VAL ); //cexp = alup_get_exponent( _CPY ); //texp = alup_get_exponent( _TMP ); //bias = alup_get_exponent_bias( _CPY ); ret = alup_match_exponents ( _CPY.data , _TMP.data , alu_Nsize(alu) ); truncated = (ret == ERANGE); exp = alup_get_exponent( _CPY ); ret = alup__add_int2int( _CMAN, _TMAN ); if ( ret == EOVERFLOW ) ++exp; (void)alup_set_exponent( _CPY, exp ); ret = alup_mov( _NUM, _CPY ); return IFTRUE( truncated || ret == ERANGE, ERANGE ); } return alup__add_int2int( _NUM, _VAL ); } return alu_err_null_ptr("alu"); }

Just in case anyone needs to see it, the exponent matching part:

Code:

int_t alup_match_exponents( void *_num, void *_val, size_t size ) { int_t ret; alup_t _NUM, _VAL, _DST, _MAN = {0}; size_t exp = 0, nexp, vexp, diff = 0; bool truncated = false; alup_init_floating( _NUM, _num, size ); alup_init_floating( _VAL, _val, size ); nexp = alup_get_exponent( _NUM ); vexp = alup_get_exponent( _VAL ); if ( nexp > vexp ) { exp = nexp; diff = nexp - vexp; _DST = _VAL; } else if ( vexp > nexp ) { exp = vexp; diff = vexp - nexp; _DST = _NUM; } if ( diff ) { alup_init_mantissa( _DST, _MAN ); /* Match exponent and align mantissa */ (void)alup_set_exponent( _DST, exp ); ret = alup__shr( _MAN, diff ); truncated = (ret == ERANGE); /* Insert assumed bit back into position */ if ( diff < _MAN.upto ) { alub_t m = alub( _MAN.data, _MAN.upto - diff ); *(m.ptr) |= m.mask; } } return IFTRUE( truncated, ERANGE ); }

I FIXED IT!!!

It always felt like I needed the original exponents somehow, now I have coded evidence:

Code:

int_t alur__add( alu_t *alu , alur_t NUM , alur_t VAL , uint_t cpy , uint_t tmp ) { if ( alu ) { int ret; //alub_t n, v; alup_t _NUM, _VAL; NUM.node %= alu_used( alu ); VAL.node %= alu_used( alu ); cpy %= alu_used(alu); tmp %= alu_used(alu); ret = IFTRUE( !NUM.node || !VAL.node || !cpy || !tmp, EINVAL ); if ( ret ) { alu_error( ret ); if ( !NUM.node ) alu_puts( "NUM.node was 0!" ); if ( !VAL.node ) alu_puts( "VAL.node was 0!" ); if ( !cpy ) alu_puts( "cpy was 0!" ); if ( !tmp ) alu_puts( "tmp was 0!" ); return ret; } alup_init_register( alu, _NUM, NUM ); alup_init_register( alu, _VAL, VAL ); if ( alur_floating( NUM ) || alur_floating( VAL ) ) { alup_t _CPY, _TMP, _CMAN, _TMAN; size_t exp, cexp, texp; bool_t truncated = false; alup_init_floating( _CPY, alu_data(alu, cpy), alu_Nsize(alu) ); alup_init_floating( _TMP, alu_data(alu, tmp), alu_Nsize(alu) ); alup_init_mantissa( _CPY, _CMAN ); alup_init_mantissa( _TMP, _TMAN ); alup_mov( _CPY, _NUM ); alup_mov( _TMP, _VAL ); cexp = alup_get_exponent( _CPY ); texp = alup_get_exponent( _TMP ); ret = alup_match_exponents ( _CPY.data , _TMP.data , alu_Nsize(alu) ); truncated = (ret == ERANGE); exp = alup_get_exponent( _CPY ); ret = alup__add_int2int( _CMAN, _TMAN ); if ( cexp || texp ) { if ( (cexp == texp) || ret == EOVERFLOW ) ++exp; } (void)alup_set_exponent( _CPY, exp ); ret = alup_mov( _NUM, _CPY ); return IFTRUE( truncated || ret == ERANGE, ERANGE ); } return alup__add_int2int( _NUM, _VAL ); } return alu_err_null_ptr("alu"); }

Gotta head to work earlier than usual today to get my nieces and nephews their xmas presents, I welcome anyone to look for edge cases with this because I need to include those in the tests as well

Judging by the lack of responses I can only predict 3 scenarios:

1. Peops lost interest (doubt this one)
2. Peops didn't bother to try any additions they though of (suspect this one strongly)
3. Peops didn't find any edge cases (doubt this one also)

Assuming number 2 then that's fine, wasn't really expecting many to try, either way I'll try a bunch of additions using the results of I think it was rnd_s()? I'm sure a few of you already know what I mean and the rest probably already understand the rough purpose, assuming I don't get any fails there either then I'll move onto subtraction which uses the same process

Ended up starting with the subtraction instead of the random additions, now I'm running into a segfault and I have no clue why, stops at this line:
alu/alup.c at master * awsdert/alu * GitHub

Edit: The segfault occurs during subtraction, both addition and subtraction are likely using the same registers so I see no reason for it to segfault after addition already succeeded

Quote:

Judging by the lack of responses I can only predict 3 scenarios:

1. Peops lost interest (doubt this one)
2. Peops didn't bother to try any additions they though of (suspect this one strongly)
3. Peops didn't find any edge cases (doubt this one also)

I would add 4. People don't understand the code.

It's certainly true for me, though out of curiosity and lack of other meaningful projects I sometimes read the posts.

Quote:

Originally Posted by thmm

I would add 4. People don't understand the code.

It's certainly true for me, though out of curiosity and lack of other meaningful projects I sometimes read the posts.

Please clarify what parts you struggle to understand, I did after all try to make it more readable

c - What does a type followed by _t (underscore-t) represent? - Stack Overflow

Quote:

However, you should also note that POSIX defines a lot of extra type names ending in '_t', and reserves the suffix for the implementation. That means that if you are working on POSIX-related systems, defining your own type names with the convention is ill-advised. The system I work on has done it (for more than 20 years); we regularly get tripped up by systems defining types with the same name as we define.

Tim S.