#define

meğerse bu da güncel hızı sunmayan bir programmış! çoklu iş parçacığıyla 1 saniyede 1 den 50 milyara kadar olan tüm sayıları artışık biçimde saydırdım! 50 tane adam öldü gitti yani! en iyi ihtimali varsayıp 25 diyelim! çift threadde, tek çekirdekte 10 milyar!

https://galeri.uludagsozluk.com/r/2381024/+

buyrun kaynak kod:
#include <stdio.h>
#include <pthread.h>
#include <sys/time.h>

#define MAX_COUNT 50000000000LL // long long int türü için LL ekledik
#define THREAD_COUNT 24 // 24 çekirdek için iş parçacığı sayısı

// işlem yapılacak fonksiyon
void* count_numbers(void* arg) {
long long start = *((long long*)arg);
long long end = start + (MAX_COUNT / THREAD_COUNT);

for (long long i = start; i < end; i++) {
// Her sayıyı yazdırmıyoruz çünkü çok büyük veri olur, ancak isterseniz yazdırabilirsiniz
// printf("%lld\n", i);
}

return NULL;
}

int main() {
struct timeval start_time, end_time;
double elapsed_time;

pthread_t threads[THREAD_COUNT];
long long start_values[THREAD_COUNT];

// Başlangıç zamanını al
gettimeofday(&start_time, NULL);

// iş parçacıklarını başlat
for (int i = 0; i < THREAD_COUNT; i++) {
start_values[i] = (MAX_COUNT / THREAD_COUNT) * i; // Her iş parçacığına başlangıç noktası
pthread_create(&threads[i], NULL, count_numbers, (void*)&start_values[i]);
}

// iş parçacıklarının bitmesini bekle
for (int i = 0; i < THREAD_COUNT; i++) {
pthread_join(threads[i], NULL);
}

// Bitiş zamanını al
gettimeofday(&end_time, NULL);

// Geçen süreyi hesapla
elapsed_time = (end_time.tv_sec - start_time.tv_sec) + (end_time.tv_usec - start_time.tv_usec) / 1000000.0;

// Sonucu yazdır
printf("1'den %lld'ye kadar sayma işlemi %.6f saniye sürdü.\n", MAX_COUNT, elapsed_time);

return 0;
}

intel core i3 (dual core) kullananlar sakın denemesin. thread count kısmında 24 yerine 2 yazıp, bekleyin! işlem belki 2025 e tamamlanır!

#include <iostream>
#include <cmath>
#include <omp.h>
#include <gmp.h>

#define LIMIT 100000000000ULL // ilk 100 milyar sayı
#define THREAD_COUNT 24 // 24 iş parçacığı kullanımı

// GMP kullanarak asal sayı kontrol fonksiyonu
bool is_prime_gmp(unsigned long long num) {
mpz_t n;
mpz_init_set_ui(n, num);
bool result = mpz_probab_prime_p(n, 15) > 0; // GMP'nin asal kontrol fonksiyonu
mpz_clear(n);
return result;
}

int main() {
unsigned long long prime_count = 0;

// OpenMP ile paralel döngü
#pragma omp parallel for num_threads(THREAD_COUNT) reduction(+:prime_count)
for (unsigned long long i = 2; i <= LIMIT; i++) {
if (is_prime_gmp(i)) {
prime_count++;
}
}

std::cout << "ilk " << LIMIT << " sayıda " << prime_count << " asal sayı bulunmaktadır." << std::endl;
return 0;
}

basit bir c programıyla bile öğrenilebilir!

kratertepesi@msi:~/Masaüstü/Programlar$ ./program
100 milyon sayı içinde 10030385 asal sayı vardır.
işlemci döngüsü: 4772581176
Hesaplama süresi: 1.0846775400 saniye
1 saniyenin 10,000'de kaçı: 10846.7754000000

kod:
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <x86intrin.h> // RDTSC için gerekli

#define LIMIT 180000000 // 1 milyar sınırı
#define CPU_FREQUENCY 4.4 // GHz cinsinden işlemci frekansı (örneğin 3.0 GHz)

int main() {
unsigned long long i, j, count = 0;
bool *is_prime = malloc((LIMIT + 1) * sizeof(bool));
if (is_prime == NULL) {
fprintf(stderr, "Bellek tahsis edilemedi.\n");
return 1;
}

// Zaman ölçüm başlangıcı
unsigned long long start = __rdtsc();

// Bütün sayıları asal varsayıyoruz
for (i = 0; i <= LIMIT; i++) {
is_prime[i] = true;
}

// 0 ve 1 asal değildir
is_prime[0] = is_prime[1] = false;

// Eratosthenes Eleği algoritması
for (i = 2; i * i <= LIMIT; i++) {
if (is_prime[i]) {
for (j = i * i; j <= LIMIT; j += i) {
is_prime[j] = false;
}
}
}

// Asal sayıları sayıyoruz
for (i = 2; i <= LIMIT; i++) {
if (is_prime[i]) {
count++;
}
}

// Zaman ölçüm bitişi
unsigned long long end = __rdtsc();

// Döngü farkını hesapla
unsigned long long cycles = end - start;

// Döngü süresi saniye olarak
double time_seconds = cycles / (CPU_FREQUENCY * 1e9); // GHz'den Hz'e dönüşüm

// Sonuçları yazdır
printf("100 milyon sayı içinde %llu asal sayı vardır.\n", count);
printf("işlemci döngüsü: %llu\n", cycles);
printf("Hesaplama süresi: %.10f saniye\n", time_seconds);
printf("1 saniyenin 10,000'de kaçı: %.10f\n", time_seconds * 10000);

// Belleği serbest bırak
free(is_prime);

return 0;
}