hkaiser changed the topic of #ste||ar to: STE||AR: Systems Technology, Emergent Parallelism, and Algorithm Research | stellar-group.org | HPX: A cure for performance impaired parallel applications | github.com/STEllAR-GROUP/hpx | This channel is logged: irclog.cct.lsu.edu
diehlpk has quit [Quit: Leaving.]
K-ballo has quit [Quit: K-ballo]
diehlpk has joined #ste||ar
diehlpk has quit [Quit: Leaving.]
hkaiser has quit [Quit: Bye!]
diehlpk has joined #ste||ar
diehlpk has quit [Client Quit]
diehlpk_work has quit [Ping timeout: 252 seconds]
K-ballo has joined #ste||ar
K-ballo has quit [Quit: K-ballo]
K-ballo has joined #ste||ar
hkaiser has joined #ste||ar
<jedi18[m]> hkaiser: I'm not able to reproduce the segmentation fault, probably because I use rand() in the test and like we'd discussed before, it dosen't produce the same values on all platforms
<hkaiser> yah
<hkaiser> it's very likely even depending on the gcc library version
<jedi18[m]> Yeah, is there a random number generator that I can use that is portable across compilers and systems?
<hkaiser> well, even if we had such a thing, we would have to reproduce the issue ;-)
<jedi18[m]> Yeah :/, I'll go over the code/ try running it many times then
<hkaiser> I'll try to reproduce it on Rostam
<zao> jedi18[m]: There's several ones in the standard library that are the same across implementations.
<zao> Mersenne Twisters etc.
<hkaiser> mostly wanted for the link to the problem be in here to have a record
<hkaiser> zao: nod, but this test uses rand() I believe, so no way to reproduce it otherwise
<zao> Is it a single invocation somewhere generating a single value or a sequence in order, or is it even more non-deterministic? I guess the only recourse is to dump out more state and soak it until it breaks again.
diehlpk has joined #ste||ar
<hkaiser> zao: sequences of numbers
<hkaiser> we have the seed, though ;-)
diehlpk has quit [Quit: Leaving.]
<dkaratza[m]> Can we postpone today's meeting for 20 mins?
<K-ballo> oh no, not rand()
<hkaiser> K-ballo: it's a leftover, I think
<hkaiser> dkaratza[m]: sure, fine with me
diehlpk has joined #ste||ar
diehlpk_work has joined #ste||ar
Yorlik has joined #ste||ar
Yorlik has quit [Ping timeout: 268 seconds]
Yorlik has joined #ste||ar
diehlpk_work has quit [Ping timeout: 252 seconds]
diehlpk_work has joined #ste||ar
<diehlpk_work> Julia seems to be the hot topic.
<diehlpk_work> Most people want to port their code from Matlab to Julia. Mostly because the code will be faster.
<hkaiser> diehlpk_work: I'm not surprised, Matlabis known not to be the fastest environment ever
<hkaiser> ms[m]: do we have a p2300 meeting today?
<diehlpk_work> hkaiser, I am more interested why all want to use Julia?
<hkaiser> diehlpk_work: because it's hyped?
<ms[m]> hkaiser: I think so, though I'll be skipping this one
<ms[m]> diehlpk_work: because it's mostly fast enough and quite ergonomic?
<ms[m]> it's also usually enough to stick with just julia instead of e.g. python+c/c++
diehlpk has quit [Read error: Connection reset by peer]
diehlpk has joined #ste||ar
Yorlik has quit [Ping timeout: 268 seconds]
<gnikunj[m]> K-ballo: I was trying to check performance difference between std::swap and std::move to swap vectors and I see no performance difference. Is std::swap for vectors implemented using move?
<gnikunj[m]> hkaiser: ^^
<hkaiser> yes
<gnikunj[m]> So, I was right in my thinking for the swap specialization.
<K-ballo> swap for vectors is implemented using swap actually
<K-ballo> the base overload of swap is implemented as three moves
<gnikunj[m]> aah, so essentially it utilizes the base swap implementation
<K-ballo> no, vector swap does no moves
<gnikunj[m]> what does it do then?
<hkaiser> conceptually it moves
<K-ballo> swaps internals
<K-ballo> conceptually, any swap is three moves
<gnikunj[m]> how is it that there is no performance difference between move and swap?
<K-ballo> you are talking copying 6 words vs copying 9 words
<K-ballo> it'd take an incredibly slow computer to notice a difference
<hkaiser> K-ballo: even the internal swap has to copy 9 words
<gnikunj[m]> here's the result for 10^5 elements: https://www.quick-bench.com/q/BWfmZqVVZZxBeGu_L-AON-arSkw
<K-ballo> the number of elements is irrelevant
<gnikunj[m]> it's still the same performance
<K-ballo> elements don't move
<K-ballo> both swap and move are O(1)
<gnikunj[m]> ohh so you're telling me the move converts to rvalue and copies the iterators to tmp and then do the same for tmp when moving to vec2?
<gnikunj[m]> so it's only the iterators copying so 9 words vs 6 words?
<K-ballo> there are no iterators
<gnikunj[m]> ok, I'm not sure about the exact terminology but I got what you're saying
<gnikunj[m]> thanks!
<gnikunj[m]> how can swap do it in 6 words though?
<K-ballo> the typical vector implementation has 3 pointers, moving a vector is copying those 3 pointers and setting the 3 sources to null
<gnikunj[m]> It still needs to have a tmp to really swap
<K-ballo> swaping two vectors is swapping those 3 pointers
<gnikunj[m]> K-ballo: right, that's what I meant
<gnikunj[m]> hkaiser: fyi, I've started to correct my sleep schedule. I woke up at 8:30 today but there wasn't any meetings today for me to show up :P
<hkaiser> :D
<hkaiser> I'm proud of you
<gnikunj[m]> I'll be proud if this continues for the next couple of days at least :D
Kalium has joined #ste||ar
diehlpk has quit [Quit: Leaving.]
K-ballo has quit [Quit: K-ballo]
K-ballo has joined #ste||ar
<K-ballo> gnikunj[m]: the specialization is a relic of another era, as soon as the optimizer inlines the moves i'll see the dead writes and produce the same codegen either way
<K-ballo> before moves were a thing swap did three copies, that's why the specialization exists