This document compares the performance of finding prime numbers between 2 and 10,000 or 5 million in C and Java. It presents the algorithms used in both languages, which perform naive prime number checking by testing all numbers for divisors up to the square root. Testing results show C outperforming Java. Further tests exploring delays in the Java code are discussed, with C consistently faster. Next steps proposed include analyzing Java's just-in-time compilation and testing more complex algorithms on a stable system.

1. C vs Java
Finding Prime Numbers
ADAM FELDSCHER
I699 PERFORMANCE DESIGN PATTERNS II
10/9/2019

2. Goals
 Need a sample test problem
 Ideally CPU Bound
 No IO
 Memory allocations may be interesting, but may add noise
 Finding Primes
 Sieve of Eratosthenes
 Memory Bound
 Naive Prime Finding
 Loop across numbers, checking [2, sqrt(n)] for divisors
 Don’t need optimal algorithm, just a consistent one

3. Algorithm (Java)
for (int iter = 0; iter < max_iter; iter++) {
// insert delays
long start_time = System.nanoTime();
for (int n = 2; n <= max_prime; n++) {// 2 - 10k, 1m, 5m
int max_divisor = (int) sqrt(n);
boolean is_prime = true;
for (int i = 2; i <= max_divisor; i++) {
if (n % i == 0) {
is_prime = false;
break;
}
}
if (is_prime) {
num_primes_found++;
}
}
long end_time = System.nanoTime();
// print things
num_primes_found = 0;
}

4. Algorithm (C)
for (int iter = 0; iter < max_iter; iter++) {
struct timespec tstart={0,0}, tend={0,0};
clock_gettime(CLOCK_MONOTONIC, &tstart);
int n;
for (n = 2; n <= max_prime; n++) {
int max_divisor = (int) sqrt(n);
bool is_prime = true;
int i;
for (i = 2; i <= max_divisor; i++) {
if (n % i == 0) {
is_prime = false;
break;
}
}
if (is_prime) {
num_primes_found++;
}
}
clock_gettime(CLOCK_MONOTONIC, &tend);
long nano_sec = (tend.tv_nsec + tend.tv_sec * 1e9) - (tstart.tv_nsec + tstart.tv_sec * 1e9);
double sec = (tend.tv_nsec / 1e9 + tend.tv_sec) - (tstart.tv_nsec / 1e9 + tstart.tv_sec);
// print things
}

5. Searching for primes [2-10k]
0
1000000
2000000
3000000
4000000
5000000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
10k C vs Java
Java C

6. Searching for primes [2-5m]
0
1E+09
2E+09
3E+09
4E+09
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
5m C vs Java
Java C

7. Delay Oddities
0
5000000
10000000
15000000
20000000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Java Delays 10k
1sec .1 sec getchar no delay

8. Delay Oddities
0
100000000
200000000
300000000
400000000
500000000
600000000
700000000
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Java delays 1m
getchar no delay

9. Next?
 JIT logging
 Watch the compilation
 More Complex Code
 Class loading
 Test on a more stable system