warpme_ has quit [Quit: Connection closed for inactivity]
kaspter has quit [Quit: kaspter]
kaspter has joined #lima
gcl has quit [Ping timeout: 240 seconds]
gcl has joined #lima
kaspter has quit [Ping timeout: 265 seconds]
kaspter has joined #lima
megi has quit [Ping timeout: 240 seconds]
chewitt has joined #lima
camus has joined #lima
kaspter has quit [Read error: Connection reset by peer]
camus is now known as kaspter
martm has joined #lima
<martm>
the constant packing/compression into register or cache variables is quite easy when you know the hardware methods and a number theory.
Elpaulo has joined #lima
<martm>
there are odd and even and prime numbers , stuff like that, philophy of a usual computer register as all know is every bit in the bitfield is a power of two, 2 in power of 0 =1 2 in power of 1 =2 etc.
<martm>
now number theory and modular arithmetic also states a fast modular exponention or euclidean algorithm which is something to look at.
<martm>
on the cpu side you have a twos complement checksumming method
chewitt has quit [Quit: Zzz..]
<martm>
it treats the constant address space as contiguous address space where the remainder is stored in 6-8bit priority encoder which redirects to cache loading decoder
<martm>
in other words cpu side stores the constants in twos complement variable which chops of the index where you are in program order
<martm>
and the remaining bits as stored by the procedure of checksum, which is a fast modulo operation
<martm>
you do not perform multiplication on the gpu, cause addition is faster, you redirect into the remainder buffer via indexing to it
<martm>
and add the base and the remainder of the modulo operation together
<martm>
so that all 32-bit constant values can be covered with very few cache entries
<martm>
so to responce to your divide and square root endless rambling shit, real men as graphitemaster on #osdev said long time ago
<martm>
solve such things with algorithms ontop of power of two buffers
<martm>
so you have a thing called twos complement subtraction or addition, boolean algebra and logics say there is two base arithmetical operations OR/XOR which corresponds to addition
<martm>
and AND which is the gate for multiplication
chewitt has joined #lima
<martm>
cause the division is nothing more then a compaounded subtraction in the theory of boolean algebra which was named after irish mathematician
<martm>
repeated subtraction as one would say
<martm>
sometimes also
chewitt has quit [Client Quit]
Barada has joined #lima
camus has joined #lima
kaspter has quit [Ping timeout: 240 seconds]
camus is now known as kaspter
<martm>
So the procedure for square root becomes, you add a greatest common divisor that is power of two
<martm>
of the two numbers you placed into the computation by the compiler
<martm>
you just add something to the number that it would use the closest power of two, rounded to the smallest of the two possible
<martm>
of course the whole point of that is, you do not want to use hardware divide and power of two operations, they incur high latency
<martm>
all this can be done cheaper
<martm>
errr... power of two/square root
<martm>
all that is done by fleshing out a priority encoder in twos complement variable seeked in 6bits subtraction based of the index
<martm>
and having the decoder to forward the proper data
<martm>
you do not have to know the value of the variable up front, you ask what is the biggest power of two
<martm>
cause the remainder will be small, rest of it will be done inside a small lookup table
<martm>
do you remember the elementary school math or number theory?
<martm>
for instance 3*3=9
<martm>
square root of 9 is 3
<martm>
9 divided with 2 is 4,5
<martm>
4 divided with 2 is 2 etc. so the square root can be derived
<martm>
is it very hard to to round big numbers to closest power ot two?
<martm>
is this very hard to make smaller numbers a look up table in cache?
<martm>
and then add stuff together, YOU SEE IT FUCKING IS NOT!
<martm>
so 1+1=2 since 1 is not counted from power of twos, closest smaller of the two powers is 2, so on 25 you have 16+8+1
<martm>
smallest of the bigger two is 8
<martm>
25=5*5
<martm>
100=10*10 bits in are 64+32+4
<martm>
32 is the one we are after
dddddd has quit [Remote host closed the connection]
<martm>
into variable whiches data is read with twos complement addition manipulations, you can store any data by the checksum, as long as you have uniform distribution of the indexes you read arbitary data from
<martm>
for an example, you 1+1+1+1+1=5 1+0+1+0+1=32 two hunks of data loaded for 5bits read, this totals to two indexes
<martm>
err 's/32/3/g'
<martm>
what are the bits of indexes or index bits, if we go 5bitsteps every time?
<martm>
yeah well those are obviously 5 and 10
<martm>
what is the fifth bit value?
<martm>
0 1 2 4 8, so it is 8 can it be?
<martm>
no
<martm>
1 2 4 8 16...it is 16
<martm>
so bit 5 i.e 16 is always toggled, cause you need it for the index
<martm>
so you loaded a sum of 4 and 2 according to my example into the priority encoder twos complement variable
UnivrslSuprBox has quit [Quit: ZNC 1.6.6+deb1ubuntu0.2 - http://znc.in]
UnivrslSuprBox has joined #lima
<martm>
what is the biggest 32bit value? it is 4.2GB or billion or something like that right
<martm>
or lets better put this that way
monstr has joined #lima
<martm>
what is the last power before sign
<martm>
?
<martm>
or what is the last power of the sign bit where twos complement is the sum of the minus bit which is the last power and all previous ones
<martm>
it is roughly two billion as i understand from the gnome-calculator
<martm>
two billion - 32 = some value
<martm>
two billion minus that value gives you the bits of interest
<martm>
or 16 or whatever was the 5th bit, hahaaa
<martm>
twos complement subtraction where subtrahand and subtractor are used properly, is always very cheap in resources and latency is two gate delays
<martm>
in other words, if bitwise operations are not available, it is very wise to use constants as powers of two for addition/subtraction and this type of packing of data
<martm>
compressing and uncompressing the way i described
<martm>
those clowns here, can not read code, they can not write code, they can not even think
martm has quit [Ping timeout: 252 seconds]
<plaes>
x
yann|work has quit [Ping timeout: 240 seconds]
yann|work has joined #lima
Kwiboo has quit [Ping timeout: 268 seconds]
cwabbott has quit [Quit: cwabbott]
cwabbott has joined #lima
megi has joined #lima
Net147 has quit [Read error: Connection reset by peer]
Net147 has joined #lima
Net147 has quit [Read error: Connection reset by peer]
Net147 has joined #lima
megi has quit [Ping timeout: 240 seconds]
maccraft123 has joined #lima
Kwiboo has joined #lima
warpme_ has joined #lima
maccraft123 has quit [Quit: WeeChat 2.6]
Barada has quit [Quit: Barada]
dddddd has joined #lima
megi has joined #lima
<enunes>
anarsoul: sorry busy days... though I did fix the comments in the MR, I just need more testing and looks like tonight might be it :)
martm has joined #lima
<martm>
so what is the priority encoder by definition, it is the class of permutations and combinations in math
<martm>
i took it in TTG -- Tallinns techiical gymnasium, among logics, and electrotechinics classes
<martm>
*technical
<martm>
since the powers of two in 6bit fields are in combinations in with other bits
<martm>
how many different values can you get?
<martm>
you are a fucking jokes dudes
<martm>
it is 2 in power of six obviously, you are retarded guys
martm has quit [Quit: Leaving]
maccraft123 has joined #lima
maccraft123 has quit [Ping timeout: 250 seconds]
yann|work has quit [Ping timeout: 240 seconds]
maccraft123 has joined #lima
maccraft123 has quit [Quit: WeeChat 2.6]
cwabbott has quit [Quit: cwabbott]
cwabbott has joined #lima
maccraft123 has joined #lima
enunes has quit [Ping timeout: 240 seconds]
enunes has joined #lima
enunes has quit [Client Quit]
enunes has joined #lima
yann|work has joined #lima
Moiman has quit [Ping timeout: 265 seconds]
Moiman has joined #lima
Moiman has quit [Ping timeout: 240 seconds]
Moiman has joined #lima
maccraft123 has quit [Quit: WeeChat 2.6]
maccraft123 has joined #lima
Danct12[m] has joined #lima
monstr has quit [Remote host closed the connection]