I'll make a few remarks that might help to clarify why the original expectation cannot be met. In a For loop it is possible there might be statements whose execution could, in principle, be carried out in parallel. To do so would involve detailed code analysis of a sort that is not realistically going to be done in an interpreted language environment. There are, as other responses indicate, ways to achieve such parallelization, or else to in other ways get code that runs much faster. One is to recast in a way that allows for vectorized computations. Whether these are or are not done in parallel can ultimately depend on very low level details of the computation, in particular whether they happen in BLAS library code that uses parallelization. Even if no parallelization happens, such code still benefits from avoiding loop overhead and avoiding memory reads (since a vectorized function can take advantage of using a single read).

This is intended as a general overview and an attempt to respond to the "why is it not what I expected" aspect of the original post. Others have already provided nice ways to better achieve the desired goal of having (much) faster code.

Another way, also mentioned, is to rewrite in a way that allows Mathematica to do the necessary code analysis and to parallelize. The Compile function, and its newer variant, can be used to achieve this goal. Alternatively, explicit use of e.g. ParallelDo can be used. In this case one would want a coarse-grained approach, wherein large blocks of the array get sent to each processor rather than individual calls each going to the next available processor (as that would lose considerable time in shipping code and values to/from subkernels to the master kernel).

why the two If[] are not evaluated at the same time

No two evaluations can happen at the same time. The processor executes machine instructions one at a time. In your analogy, the painter is the cpu. You can't magically create an extra CPU just by re-ordering the instructions.The same painter is painting the wall. The painter can paint in strips from left to right, or the painter can alternate strips on the right and left, or the painter can do any number of other patterns. But it requires the same amount of paint and the same amount of work by the painter.

Continuing this analogy, adding another painter isn't as trivial as it may sound. You can't just send another painter into the room and expect the productivity to double. The second painter needs a second brush at least. It's best to divide the paint into two containers so the painters aren't bumping into each other refilling their brush. And it's best to assign each painter a specific half of the wall so that they aren't bumping into each other or duplicating effort. And you have double the cleanup.

So, where in your code examples have you ever added a second painter? You're always using just one painter. You've altered the sequence in which the painting gets done, but you haven't added any extra painters. This seems so blindingly obvious to me that I fear I just don't understand what you're saying. What makes you think you've added an extra painter? Have you read something somewhere about optimization that motivated this example? Maybe we can examine your sources of information and show you where you've gone off the rails. I'm still suspicious that this is some sort of trolling effort.

Eric Rimbey, Neil Singer and Michael Rogers I appreciate your replies; your alternatives are really fast and I learnt from them. When I wrote the entry I was not thinking about other ways to do it but with the intention to know why the two If[] are not evaluated at the same time, because I though that the code with one If[] and the one with the two If[] would sweep the array as in the following GIF : and that's why I spoke of parallel. The analogy is that two people could paint a wall twice as fast as one, but ten people would get in each other's way. I am learning the language, I want to understand its functions and how they work, which is the order in which things go evaluated inside a particular function.

By the way Neil, the Compiler does work with text? Let us say that the element of the second column were text ("ONE" instead of 1), how it will be? Thanks

Mathematica automatically uses "vectorized" operations for some basic math functions, which take advantage of pipelining and parallelization, via libraries it is built with (such as the Math Kernel Library). The For[] loop takes ~4.5 sec. on my computer, about 50 times as long as the following:

SeedRandom[0]; (* for reproducibility *)
mat = RandomInteger[5, {6000000, 2}];

6000000 - Total[Unitize@Total[Abs[mat - 1], {2}]] // AbsoluteTiming
(*  {0.092755, 165749}  *)

num1 = 0;
AbsoluteTiming[
 For[i = 1, i <= 6000000, i++, 
  If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1];]]
num1
(*
{4.53598, Null}
165749
*)

You can see that the For[] is not very efficient. If you replace the If[] statement by the increment statement num1 = num1 + 1, the timing drops to ~3 sec. If you replace it by a no-op Null, the timing drops to ~1.5 sec., which is the overhead for a For[] loop that does nothing but increment i six million times. Aside from the fact that the lines a For[] loop are executed sequentially and not in parallel as has been pointed out, what one can expect to save is half the 1.5 sec. in incrementing i half as much.

Legibus,

While Mathematica offers For[] and other looping constructs, It is rarely a good idea to use them. You can almost always compute faster using Mathematica's list handling instead. In your case, using For[] on my machine:

In[3]:= num1 = 0;
AbsoluteTiming[
 For[i = 1, i <= 6000000, i++, 
  If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1];]]
Print[num1]

Out[4]= {4.65165, Null}

During evaluation of In[3]:= 166569

However you get more than an order of magnitude speedup with this code (while getting the same answer):

In[43]:= AbsoluteTiming[
 Total[Map[If[#[[1]] == #[[2]] == 1, 1, 0] &, mat]]]

Out[43]= {0.367711, 166569}

You can also rely on Compilation to get more speed:

cS = Compile[{{x, _Real, 1}}, If[x[[1]] == x[[2]] == 1, 1, 0], 
  RuntimeAttributes -> {Listable}]
In[7]:= Total[cS[mat]] // AbsoluteTiming

Out[7]= {0.327464, 166569}

You can further parallelize the list operations but often you will actually slow things down because the overhead of parallelization swamps the super-fast list-based operations. Parallel speedups are highly dependent on the actual code.

Regards,

Neil

The example with the Monitor function shows that it takes more than two times, if I do what you suggest it will be more than 10 times slower not faster as you say.

The question is why the iterations does not happens at the same time and if possible how could be done. How to make the If evaluations hapen in parallel.

I don't understand the point of the i^2 example.

As I read your original post, you're expecting a nearly double speed up by halving the number of iterations. But you're also doubling the number of computations in each iteration, so the total number of computations is about the same. I don't know why you'd expect any speedup.

Consider this modification instead of updating num1 and num2 we compute the square of the i row

AbsoluteTiming[
For[i=1, i<=6000000, i++,
If[mat[[i,1]]==1 && mat[[i,2]]==1 ,i^2];
]]

result 7.461 seconds

AbsoluteTiming[
For[i=1, i<= 3000000,i++,
If[mat[[i,1]]==1 && mat[[i,2]]==1 ,i^2];
If[mat[[i+3000000,1]]==1 && mat[[i+3000000,2]]==1 ,i^2];
]]

result 6.647 seconds