weilewei has quit [Remote host closed the connection]
bita_ has quit [Ping timeout: 260 seconds]
akheir has quit [Quit: Leaving]
hkaiser has quit [Quit: bye]
kale[m] has quit [Ping timeout: 244 seconds]
kale[m] has joined #ste||ar
kale[m] has quit [Ping timeout: 264 seconds]
kale[m] has joined #ste||ar
chelsea[m] has left #ste||ar ["Kicked by @appservice-irc:matrix.org : Idle for 30+ days"]
Yorlik has joined #ste||ar
kale[m] has quit [Ping timeout: 260 seconds]
kale[m] has joined #ste||ar
kale[m] has quit [Read error: Connection reset by peer]
kale[m] has joined #ste||ar
kale[m] has quit [Ping timeout: 260 seconds]
kale[m] has joined #ste||ar
Pranavug has joined #ste||ar
<Pranavug>
Hey everyone, as a part of my GSoC project I want a few suggestions on the following subproblem: How to measure the time a particular node(all cpus on a node) was busy computing(In a way busy-time) using HPX(performance counters?). Currently, I am using gettimeofday at various places of computation and adding the time intervals.
pranav_ has joined #ste||ar
Pranavug has quit [Ping timeout: 240 seconds]
pranav_ has quit [Quit: Leaving]
Pranavug has joined #ste||ar
akheir has joined #ste||ar
<zao>
Pranavug: In general if you're measuring durations you may want a clock that's at least monotonic, preferably not affected by leap seconds. std::chrono::steady_clock isn't bad I believe.
<zao>
You might want to specify what you consider "busy" - is it just being inside a particular block of code, or do you consider a distinction between actual computation and being "busy" waiting on synchronization or I/O?
<zao>
(I don't know anything about your gsoc project, just general musings)
hkaiser has joined #ste||ar
<Pranavug>
Ok thanks zao. Appreciate your help
<Pranavug>
By "busy" i mean, time spent on pure computation by excluding times spent on data transfer across nodes, I/O etc
<Pranavug>
Please let me know if you want me to clarify further.
<gnikunj[m]>
Pranavug I think you're looking for the thread idle rate performance counter. It let's you know percentage resource utilization of all threads.
<Pranavug>
gnikunj: actually I want to know absolute time and not percentage
<Pranavug>
It will be used for load balancing and amount of work that can be relocated from each node. That's why
<Pranavug>
By absolute time: I mean total non-idle time i.e. time spent only on computation
<gnikunj[m]>
Pranavug I see. parsa is doing similar stuff. He should be able to help.
<gnikunj[m]>
From the looks of it, I would use a profiler. In a timeline view, you should get a clear picture of imbalance.
<zao>
gnikunj[m]: Tricky if it's supposed to be on-line tho.
<Pranavug>
Ok thanks gnikunj, I think I will wait for Parsa to answer here then?
<Pranavug>
zao: yeah right, I am not sure how helpful profilers would be for on-line load balancing
kale[m] has quit [Ping timeout: 260 seconds]
kale[m] has joined #ste||ar
<hkaiser>
Pranavug: absolute time is useless
<hkaiser>
in the end you have to relate the absolute time measured for something to the overlal time spent anyways, which gives you relative percentage in the end
<Pranavug>
hkaiser: I am using absolute time to calculate difference in the amount of work performed by each of the nodes. To quantify the difference of work, I am using (absolute time spent on computation)/(total amount computation on that node)
<Pranavug>
Amount of computation, is more of an implementation detail and not FLOPS or something
<Pranavug>
Depending on the difference I will be reassigning work on different nodes. Using percentages that wont be possible in the case when nodes don't have same type of CPU's
<Pranavug>
Absolute time will help in that case
<zao>
Wouldn't a node with little work to do and a node that's very busy with I/O look quite similar perf-wise?
<Pranavug>
Ok the answer is no, because all the I/O is done at the start. Delays would be only because of the data transfer across the nodes for my implementation
<hkaiser>
Pranavug: so you calculate the ration yourself, why not use percentages to begin with?
<hkaiser>
and the idle-rates nikunj mentioned are exactly that - time spent on doing useful things per time unit
<Pranavug>
hkaiser: Ok, right so you are suggesting to use percentages instead of absolute times in the fraction I am calculating. Also reset the performance counter, once the load balancing is performed, because the old values don't make sense in the newer partitions?
pranav has joined #ste||ar
pranav has left #ste||ar [#ste||ar]
pranav has joined #ste||ar
pranav has left #ste||ar [#ste||ar]
pranav has joined #ste||ar
<Pranavug>
Very helpful
hkaiser has quit [Quit: bye]
Pranavug has quit [Quit: Leaving]
bita_ has joined #ste||ar
bita_ has quit [Ping timeout: 260 seconds]
kale[m] has quit [Ping timeout: 264 seconds]
kale[m] has joined #ste||ar
K-ballo has quit [Quit: K-ballo]
K-ballo has joined #ste||ar
hkaiser has joined #ste||ar
hkaiser_ has joined #ste||ar
hkaiser has quit [Ping timeout: 244 seconds]
bita_ has joined #ste||ar
<gonidelis[m]>
What are the core differences of function template specialization and function overloading? Why choose one way over the other? I know that compiler first looks for overloads. But what is their main functional difference?
<gonidelis[m]>
@channel
<gonidelis[m]>
I also know that there is no partial specialization for function templates
<kale[m]>
Hey everyone! I bring in some good news. Starting now, you can install phylanx release build on your machines using pip install phylanx(it's finally on PyPI). A few caveats: it works with python 3.7 currently and support for python 3.8 will be added as soon as the phylanx issue is fixed. Secondly, you will need to export PHYLANX_PLUGINS_PATH to the <pip-install-dir>/phylanx-libs/phylanx. I will add a few more changes for an easier
<kale[m]>
integration soon :)
<gonidelis[m]>
kale[m]: bravo!!!
<K-ballo>
gonidelis[m]: they are completely different mechanisms, but you seem to know that already..
<K-ballo>
in the rare cases that both overloads and specializations are sensible, prefer overloads? although it's hard to imagine such a case
<gonidelis[m]>
The fact the the compiler picks a different function when you have `template<class T> void f( T );` `template<class T> void f(T*)` `template<> void f<>(int*)` and you just swap the last two functions is mindblowing...
<gonidelis[m]>
K-ballo: herb sutter?
<K-ballo>
indeed
<gonidelis[m]>
K-ballo: know him?
<K-ballo>
lol, herb?
<K-ballo>
the C++ wg21 convener?
<K-ballo>
he "runs" the committee
<gonidelis[m]>
Is he like the top guy?
<K-ballo>
mmh no
<gonidelis[m]>
ok so he must be like an esteemed guy then ? :p
<K-ballo>
he actually runs the committee, no quotes
<K-ballo>
and is one of the best C++ presenters/writers out there
<gonidelis[m]>
ok fair
<gonidelis[m]>
have you met him?
<K-ballo>
sure, he's at every committee meeting
<K-ballo>
as well as most conferences
kale[m] has quit [Ping timeout: 260 seconds]
kale[m] has joined #ste||ar
<gonidelis[m]>
K-ballo: when are committee meetings executed?
<K-ballo>
in the old world, thrice a year
<K-ballo>
there's currently a meeting ban until at least the end of the year
<gonidelis[m]>
Could one just be a spectator in such a meeting, in the old world?
<K-ballo>
yes, they are open
<gonidelis[m]>
wow... entry price?
<gonidelis[m]>
is there anyq
<gonidelis[m]>
? *
<K-ballo>
free.. but you have to pay for plane tickets, accomodation, food, etc
<gonidelis[m]>
wow....
<K-ballo>
where are you located?
<gonidelis[m]>
greece
<K-ballo>
I don't think there have been any meetings there, I don't think greece is a wg21 member
<gonidelis[m]>
it's not
<K-ballo>
we were supposed to have one in bulgaria past june, that's "close" no?
<gonidelis[m]>
I sure could travel in europe though... in a renwed world
<K-ballo>
we had one in prague in february, that was the last one
<gonidelis[m]>
pretty close... especially to my city
<gonidelis[m]>
So you guys go to all of these? I mean, you have jobs how do you escape them? Plus it's pretty far from both south and north america
<K-ballo>
not all, but it is part of the job
<gonidelis[m]>
That sounds very very interesting
<parsa>
hkaiser_: mahesh has managed to uploaded a wheel for Python 3.7 to PyPI (https://pypi.org/project/phylanx/). tested and works on fedora 30