Advanced Fortran Programming : 017 : Timing Code in fortran Video Lecture | Introduction to Fortran Programming (AdvancedLevel) - Database Management

hello guys my name is Aaron and welcome
to my channel this series is a series of
tutorials on advanced fortran
programming now in this tutorial we'll
be looking at a very simple concept but
but this will be this concert will be
very very useful for you guys in the
future we will be looking at some timing
functions in fortran from which you can
see whether your code is running good or
not okay now what I have here is a
simple program to do a simple
mathematics multiplication okay I walk
you guys through what I have here is I
don't want the speed only this P here
but anyway what I what do you have here
is I have a parameter n whose values
thousand i have three I trade the
variables I JK I JK and the three
mattresses n by n n by n matrices namely
a B and C okay and what I have here is
that I have three very three variables T
1 T 2 and EP now using the inbuilt the
inbuilt the allocation mechanisms I said
a 1 in the matrix a to b 1 and b 2 b 0
but on but if but then the every i comma
I index using this do loop I set the
value to be one so what do you guys know
what you guys will get is that this B
matrix will be nothing but your identity
matrix thereby you multiply a and B will
get a back itself and I said see to be
zero and now the timing operations will
come here see there is a system in
intrinsic fung intrinsic subroutine in
fortran called a cpu underscore time now
water is what it will do is at it will
calculate the current second current
time it will measure the current time
when this function is called and
allocates that value in seconds to the
value T 1 to the variable T 1 okay and
what I have here is a nested Nestor do
loop nested loop for doing a matrix
multiplication a nested loop for doing
an ester three nested loop for doing a
matrix multiplication and doesn't matter
if i were to know this is i j and this
should be care but anyway is an ester do
look for doing matrix multiplication
it's over here I said this module rings
madam
animation by loops whereas what I do
here I call it I call the same CPU
underscore time function and set the
value t2 over here so what will this
will do is that at this point when the
compiler it comes to this point it will
measure the system time okay and then
when when it comes to this point it will
measure the system time these two times
will be different and now what EP does
is that it will store the difference
between the times obviously t2 will be
greater than t1 so t2 minus t1 will be
the will be the time in seconds taken
for the program to run this part of the
code okay now that being said now that
being said EP will store over here and
if they were your matrix e is smart you
can use this statement away and it can
uncommon the statement to print it and
to print the matrix to see how the
result turns out to be and then I stay
right this print statement over here
saying there's a time for multiplication
of the loop in seconds is EP okay next
what I do is that I just repeat the same
process on the top okay and this time to
give a comparison what I'm doing is that
I'm doing the same matrix multiplication
with matrix multiplication okay with the
mat malfunction with the mat malfunction
nothing more nothing less now if I had
to do that if ever to do that I am doing
the same using the same variables on top
and bottom to get the same subroutines
CP underscore time at the top and the
bottom they get the same to do the same
operation similar to that okay and I get
the difference in x similarly difference
in times now in this line i'm printing
the values okay now what i did is that
now if you have to compile this compare
build and execute this we will get the
difference in x okay and that will be
printed in the printed in the terminal
okay and now what I did is that I've
also written a small shell script called
as timing data such it's pretty
straightforward list all replace the
screen lists all the contents the most
of the object executable or mod files
compiles the four and five builds the
footer and file to get an executable and
then runs executable here but before
that I have this new
good line you think all this time now
what it does is that it would this is a
shell command that is that the list of
how much time it took for the executable
thing to work out so this is a these are
like an overall thing you can keep in
mind but it's not much important but
it's kind of necessary now to run this
what I do what I do okay I have the
terminal ready here now let me clear
this up okay I favor to run this file
bash that as such okay I already change
the file permission to it provide run
this it does some operations now it's
executing wait for some seconds there
you have it it now it prints of value it
says that the time taken for the
multiplication in the loop is like is
something like four point three eight
eight seconds whereas a marg matrix
multiplication mean father during the
using the commands is less than is less
than point four seconds approximately 0
point 3 32 seconds and whereas this one
this these three statements these come
because of the time ok now this real
time is actually the time taken for is
actually a time taken for the system
processor to work and all user time it I
think it user time it takes the other
processes also into consideration there
are slight slight differences in it and
system time takes care it takes how much
time it took for stopping memory doing
other all the rim it some similar some
simple process regarding file input
output and all okay there if you guys
check on the internet this will be with
you can get the answer but this is not
that the order so important okay this is
just given time suppose if you have to
ask input the input the values of each
and every entry in the matrix then the
user time will increase and the real
time will only take the computation time
and laws and stuff now if you guys
notice you guys notice the reason why I
told is that in this function in this
program over here in in this program
over here in this program over here we
do the same matrix multiplication using
do loop that as we do the same address
manipulation using the intrinsic
function you guys notice this loop is
slow
over 17 several times slower and
compared to the function and if you were
to give even bigger value say since than
10,000 sorry that doesn't be too much
and you take so much time I just keep
2000 even this is too much good run this
this will take even longer time watch
okay you have to wait so something it
will take about 15 seconds or 20 seconds
or something of that sort because the
matrix is big so do that do that job if
you take some time ok I think 2000s too
much I should have incremented it slowly
this will take like eight times the time
so even then it should work some
sometime around now I think I think a
few more seconds and this multiplication
will be done ok now you are testing my
patience
yeah Wow how about that his entire
matrix multiplication takes to pick 62
seconds approximately but surprisingly
the internal function the internal
matrix multiplication function took only
three point two four eight second to
3.25 circus and if you guys know and if
you guys notice you get the real times
like real time seconds a user 10 seconds
accordingly also now this kind of thing
can be very useful if you are especially
you know optimizing your code and all if
you want to take you away which part of
a code is taking the most number of most
x-mas time and you want to know do some
optimises on that that and if you want
to see which part is taking less time
and all this kind of a method will be
useful and it's not very important but
they say this this can be very very
Bennett but it's not very important but
this can be very very beneficial for
those people who wanted to you know make
your code much faster so that consumes
less time and cuando optimize a lot ok
and now why could the widest reason it's
maybe because of the indices and all
suppose you prefer to changes in dice
too I just flip the in dice ok I save it
now this time instead of tau instead of
after the two thousand i just save a
thousand because i don't want you guys
to wait for a long time say I run this I
think this will also take some time but
ok even when even when change it's like
it's likes little slow it's like it's
three seconds and point three four over
here let me just change this to I as if
this to be some kind of an algorithm
that's it now run this again remember
3.37 and 0.34 and if you run this is
this will take some more time because of
this will take some more time yeah and
you get this to be 4.4 reason reason is
because reasons because photon has
column contagious and when we doing this
we actually jumping from rose coming
from different roast different rows
they're like striding from browse across
row so it will take some it's taking
much time over here but when he takes
when you do some column continuous
options it will be little faster ok
that's all i have for you guys in this
tutorial this is very simple but this
will be this a very effective topic for
you guys thank you guys for watching and
I'll see you guys next tutorial with
another difference another different
application by