Thread t1 = new Thread(LargePrimeComputer.Compute);
Thread t2 = new Thread(LargePrimeComputer.Compute);

t1.Join();
t2.Join();

The fact is, the absolute last place you want to see drivers is in the hypervisor

RO>Thread t1 = new Thread(LargePrimeComputer.Compute);
RO>Thread t2 = new Thread(LargePrimeComputer.Compute);

RO>t1.Join();
RO>t2.Join();
RO>

Sheduler  s = new Sheduler( LongTask );

Thread t1 = new Thread(LargePrimeComputer.Compute);
Thread t2 = new Thread(LargePrimeComputer.Compute);

s.Attach( t1 );
s.Attach( t2 );

System.Shedulers.Add( s );

RO>

S>http://gzip.rsdn.ru/Users/Profile.aspx?uid=28760 фоткал не я. Достаточно?

Внутренняя ошибка сервера

URL: /Users/Profile.aspx?uid=28760

An error has occurred while establishing a connection to the server. When connecting to SQL Server 2005, this failure may be caused by the fact that under the default settings SQL Server does not allow remote connections. (provider: TCP Provider, error: 0 — No such host is known.)

if (operation == "ARRAY_ACCESS") then begin
  array_operand = array_table.lookup_slow(operand1);
    index_operand = calculator_engine.evaluate_slow_scalar(operand2);
    if (index_operand == previous_operand) then goto ARRAY_ACCESS_FAST;
    if (index_operand.type != "int32") then throw_slow new InvalidArgumentException("Variable i has wrong type!");
    if (index_operand.slow_as_int() > array_operand.calc_length_through_iteration()) 
      then throw_slow new ArrayOutOfBoundException("Variable i is to large!");
      else if index_operand.slow_as_int() < 0 
          then throw_slow new ArrayOutOfBoundException("Variable i is to small!");
end

int func(int a, int b) {
  return a+b;
}

int res = 0;
for(int i = 0; i < count; ++i) {
  res = func(res, i);
}

for(int i = 0; i < count; ++i) {
  res = res + i;
}

       -finline-functions
           Integrate all simple functions into their callers.  The compiler heuristically decides which functions are simple enough to be worth integrating in this way.

           If all calls to a given function are integrated, and the function is declared "static", then the function is normally not output as assembler code in its own right.

           Enabled at level -O3.

       -finline-functions-called-once
           Consider all "static" functions called once for inlining into their caller even if they are not marked "inline".  If a call to a given function is integrated, then the
           function is not output as assembler code in its own right.

           Enabled if -funit-at-a-time is enabled.

       -fearly-inlining
           Inline functions marked by "always_inline" and functions whose body seems smaller than the function call overhead early before doing -fprofile-generate instrumentation
           and real inlining pass.  Doing so makes profiling significantly cheaper and usually inlining faster on programs having large chains of nested wrapper functions.

       -O
       -O1 Optimize.  Optimizing compilation takes somewhat more time, and a lot more memory for a large function.

           With -O, the compiler tries to reduce code size and execution time, without performing any optimizations that take a great deal of compilation time.

           -O turns on the following optimization flags: -fdefer-pop -fdelayed-branch -fguess-branch-probability -fcprop-registers -floop-optimize -fif-conversion -fif-conversion2
           -ftree-ccp -ftree-dce -ftree-dominator-opts -ftree-dse -ftree-ter -ftree-lrs -ftree-sra -ftree-copyrename -ftree-fre -ftree-ch -funit-at-a-time -fmerge-constants

           -O also turns on -fomit-frame-pointer on machines where doing so does not interfere with debugging.

           -O doesn’t turn on -ftree-sra for the Ada compiler.  This option must be explicitly specified on the command line to be enabled for the Ada compiler.

       -O2 Optimize even more.  GCC performs nearly all supported optimizations that do not involve a space-speed tradeoff.  The compiler does not perform loop unrolling or function
           inlining when you specify -O2.  As compared to -O, this option increases both compilation time and the performance of the generated code.

           -O2 turns on all optimization flags specified by -O.  It also turns on the following optimization flags: -fthread-jumps -fcrossjumping -foptimize-sibling-calls -fcse-fol‐
           low-jumps  -fcse-skip-blocks -fgcse  -fgcse-lm -fexpensive-optimizations -fstrength-reduce -frerun-cse-after-loop  -frerun-loop-opt -fcaller-saves -fpeephole2 -fsched‐
           ule-insns  -fschedule-insns2 -fsched-interblock  -fsched-spec -fregmove -fstrict-aliasing -fdelete-null-pointer-checks -freorder-blocks  -freorder-functions -falign-func‐
           tions  -falign-jumps -falign-loops  -falign-labels -ftree-vrp -ftree-pre

           Please note the warning under -fgcse about invoking -O2 on programs that use computed gotos.

       -O3 Optimize yet more.  -O3 turns on all optimizations specified by -O2 and also turns on the -finline-functions, -funswitch-loops and -fgcse-after-reload options.

       -O0 Do not optimize.  This is the default.

       -Os Optimize for size.  -Os enables all -O2 optimizations that do not typically increase code size.  It also performs further optimizations designed to reduce code size.

           -Os disables the following optimization flags: -falign-functions  -falign-jumps  -falign-loops -falign-labels  -freorder-blocks  -freorder-blocks-and-partition
           -fprefetch-loop-arrays  -ftree-vect-loop-version

           If you use multiple -O options, with or without level numbers, the last such option is the one that is effective.

       Options of the form -fflag specify machine-independent flags.  Most flags have both positive and negative forms; the negative form of -ffoo would be -fno-foo.  In the table
       below, only one of the forms is listed---the one you typically will use.  You can figure out the other form by either removing no- or adding it.

       The following options control specific optimizations.  They are either activated by -O options or are related to ones that are.  You can use the following flags in the rare
       cases when "fine-tuning" of optimizations to be performed is desired.

S>

int dosum(int a, int b) {
    return a + b;
}

#include <stdio.h>
#include <time.h>

int dosum(int a, int b);

int main(int argc, char** argv) {
    int count1 = atoi(argv[1]);
    int count2 = atoi(argv[2]);
    long c = clock();
    int l = 0, i, j;
    for( j = 0; j < count1; ++j ) {
        for( i = 0; i < count2; ++i ) {
            l = dosum(l, i);
        }
    }
    long end = clock(); 
    printf( "l = %d\n", l );
    printf("%f\n", (float)(end - c) / (float)CLOCKS_PER_SEC);
    return 0;
}

public interface DoSum {
    int dosum(int a, int b);
}

public class DoSumImpl implements DoSum {
    public int dosum(int a, int b) {
        return a + b;
    }
}

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.net.*;

public class Test4 {
    public static void main(String[] args) throws Exception {        
        int count1 = Integer.parseInt(args[1]);
        int count2 = Integer.parseInt(args[2]);
        // Можно заменить эту строку
        DoSum d = (DoSum) Class.forName(args[0]).newInstance();
        // Двумя вот этими, тогда код будет подгружаться с сервера (и локальные DoSumImpl.java/DoSumImpl.class можно вообще удалить):
        //ClassLoader cl = new URLClassLoader(new URL[] { new URL("http://wfrag.org/files/") });
        //DoSum d = (DoSum) cl.loadClass(args[0]).newInstance();

        // Прогреем JVM :)
        test(d, count1+1, count2+1);
        test(d, count1+2, count2+2);
        System.err.println("Real results");
        // А вот теперь реально замерим:
        test(d, count1, count2);
        test(d, count1, count2);
    }

    public static void test(DoSum d, int count1, int count2) throws Exception {
        ThreadMXBean mx = ManagementFactory.getThreadMXBean();
        long c = mx.getCurrentThreadCpuTime();
        int l = 0, i, j;
        for( j = 0; j < count1; ++j ) {
            for( i = 0; i < count2; ++i ) {
                l = d.dosum(l, i);
            }
        }
        long end = mx.getCurrentThreadCpuTime(); 
        System.err.println( "l = " + l);
        System.err.println((float)(end - c) / 1000000000);
    }
}

wfrag@fragentoo ~/test/1 $ gcc -O3 -funroll-loops -finline-functions dosum.c -o libdosum.so -shared
wfrag@fragentoo ~/test/1 $ gcc -O3 -funroll-loops -finline-functions -L. -ldosum test4.c 
wfrag@fragentoo ~/test/1 $ LD_LIBRARY_PATH=. ./a.out 10 1000000000
l = 451808768
48.170000

wfrag@fragentoo ~/test/1 $ gcc -O3 -funroll-loops -finline-functions dosum.c -o libdosum.so -c
wfrag@fragentoo ~/test/1 $ gcc -O3 -funroll-loops -finline-functions -L. -ldosum test4.c 
wfrag@fragentoo ~/test/1 $ ./a.out 10 1000000000
l = 451808768
43.780000

wfrag@fragentoo ~/test/1 $ cat test4.c dosum.c  > test4combined.c
wfrag@fragentoo ~/test/1 $ gcc -O3 -funroll-loops -finline-functions test4combined.c 
wfrag@fragentoo ~/test/1 $ ./a.out 10 1000000000
l = 451808768
1.850000

wfrag@fragentoo ~/test/1 $ /opt/sun-jdk-1.6.0.06/bin/javac Test4.java 
wfrag@fragentoo ~/test/1 $ /opt/sun-jdk-1.6.0.06/bin/java -cp . -XX:CompileThreshold=10 -server  Test4 DoSumImpl 10 1000000000
l = 1618564864
27.84
l = 490353676
30.24
Real results
l = 451808768
5.64
l = 451808768
5.65