Maybe we can leverage the idea behind your gifs. Try the following experiments (deliberately designed for low performance so you can watch progress):

testImage = ConstantImage[GrayLevel[.5], {200, 200}];
Monitor[
  For[col = 1, col <= 200, col++,
   For[row = 1, row <= 200, row++,
    testImage = ReplaceImageValue[testImage, {col, row} -> .8]]],
  testImage] // AbsoluteTiming

====

testImage = ConstantImage[GrayLevel[.5], {200, 200}];
Monitor[
  For[col = 1, col <= 100, col++,
   For[row = 1, row <= 200, row++,
    testImage = ReplaceImageValue[testImage, {col, row} -> .8];
    testImage = ReplaceImageValue[testImage, {col + 100, row} -> .2]]],
  testImage] // AbsoluteTiming

====

testImage = ConstantImage[GrayLevel[.5], {200, 200}];
Monitor[
  For[col = 1, col <= 100, col++,
   For[row = 1, row <= 100, row++,
    testImage = ReplaceImageValue[testImage, {col, row} -> .9];
    testImage = ReplaceImageValue[testImage, {col + 100, row + 100} -> .6]];
   For[row = 1, row <= 100, row++,
    testImage = ReplaceImageValue[testImage, {col, row + 100} -> .1];
    testImage = ReplaceImageValue[testImage, {col + 100, row} -> .4]]],
  testImage] // AbsoluteTiming

While Michael's post is still a bit faster by avoiding the If[], this addition to the Compiled version makes it parallel and almost the same speed as Michael's clever post which avoids the If[] (I forgot to try the parallelization last night which was the whole reason for showing you the compile in the first place!)

cS = 
 Compile[{{x, _Real, 1}}, If[x[[1]] == x[[2]] == 1, 1, 0], 
  RuntimeAttributes -> {Listable}, Parallelization -> True]


In[9]:= Total[cS[mat]] // AbsoluteTiming

Out[9]= {0.121325, 165749}

This dovetails with what both Michael and I said -- you should always rely on the built-in optimization of list or vector processing capabilities of Mathematica.

As to your question about text in Compile, String is not a valid type for Compile[]. However, as we have shown above, you can get speedups (even for string functions) by relying on Mathematica's built-in optimizations.

If you want to experiment with Mathematica's Parallelization you can do something like this by changing the For to a Do so it can be parallelized (For loops can't necessarily be done out of order). Note it is always faster than For but still painfully slow compared to the vector approaches.

num1 = 0;
AbsoluteTiming[
 Do[If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1], {i, 1, 
   6000000}]]
num1 

(*  {3.06585, Null}  *)

num1=0;
n = 3;
CloseKernels[];LaunchKernels[n];
AbsoluteTiming[ParallelDo[If[mat[[i,1]]==1&&mat[[i,2]]==1,num1=num1+1],{i,1,6000000}]]
num1
(* {1.45851, Null} *)

Try running this with 1,2,3,4, etc Kernels. You see diminishing returns after using 3 Kernels to do the parallel processing -- overhead dominates. But this will give you a feel for what is going on.

Regards

Neil

Okay, I'm going to assume this is a serious question, sorry for trying to be funny.

In your example with Monitor, you added even more computations to each iteration, so of course it takes longer. I'm baffled why you think otherwise, so I'll assume there's just some miscommunication going on here.

Moving on to your first example, you are executing the following expression 6 million times:

If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1]

Now let's split it up, but for illustration purposes let's start with something a bit differently than what you did:

num1 = 0; num2 = 0;
AbsoluteTiming[
 For[i = 1, i <= 3000000, i++,
  If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1]];
 For[i = 3000001, i <= 6000000, i++,
  If[mat[[i, 1]] == 1 && mat[[i, 2]] == 1, num1 = num1 + 1]];]

We have 3 million iterations in the first For and 3 million in the second For, and they clearly happen one after the other. And they evaluate the same expression in each iteration. So, we still have 6 million evaluations of that expression. We should expect no speed up.

Now let's look at how you split it up:

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

We only have 3 million iterations in total, but our core expression shows up twice in each iteration (slightly altered, but essentially the same). When i=1, we check the first pair in the matrix AND we check the 3000001st pair in the matrix. So, we're still evaluation that same expression (essentially) 6 million times. We haven't pre-computed anything. The cost of each evaluation is the same, and we do it 6 million times.

You say you expect the overall time to be half as long, but that means each evaluation would have to be half as long on average. Why would we expect that? My joke was trying to point this out. If halving the number of iterations but doubling the work done in each iteration could reduce the total time by half, then doing 1/10 the iterations with 10 times the work in each should then take only 1/10 the total time. Same logic. If you reject this for 10, why don't you reject it for 2?

If your objective is to understand the timings, then I hope this explanation helps. If your objective is just to improve performance, then you could use Do instead of For, or (as I showed above) you could just use Count.

Since you keep mentioning "parallel", I'll point out that there are ways to get Mathematica to use multiple kernels, e.g. ParallelDo and other functions with the Parallel prefix. In my experience these functions can be tricky to use correctly. Maybe others with more understanding of performance can explain whether they'd be useful here.

and this is even faster:

In[8]:= AbsoluteTiming[Total[Map[cS, mat]]]

Out[8]= {0.266503, 166569}

I guess making the function Listable actually slows it down. I would remove the RuntimeAttributes from the definition of the Compiled function.

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.

The i^2 is a simpler computation that replace the updating num1 and num2, (even doing nothing give differences of just 1 second faster). Yes I was expecting nearly double speed because althoug there are two If statements to me they happens at the same time (iteration). Let us Monitor both:

num0=0; num1=0; num2=0;
AbsoluteTiming[
Monitor[
For[i=1, i<=6000000, i++,
If[mat[[i,1]]==1 && mat[[i,2]]==1 ,num0=num0+1];

If[i<=3000000,
If[mat[[i,1]]==1 && mat[[i,2]]==1 ,num1=num1+1];
If[mat[[i+3000000,1]]==1 && mat[[i+3000000,2]]==1 ,num2=num2+1];
]
],{i,Style[num0,Red],Style[num1+num2,Blue]}]]

when i=3000000 the second part is already finish gives {i=3000000, 83475, 166341}, for a final result {i=6000000, 166341, 166341}, in 15.01 seconds.

I want to know why it seems to be happening at he same iteration but according with las result 15.01 seconds they are really not, beacuse the time to do both takes more than the sum of the times it would take to do it individually.

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