#define

insan ömrünü 1 saniyeye sığdıran makina

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!

görsel

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;
}

ellerim bos gonlum hos
204 gün önce

0 0 ...

ilk 100 milyar sayıda kaç asal var

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;
}

ellerim bos gonlum hos
208 gün önce

0 0 ...

işlemcinin saniye başına hesapladığı komut sayısı

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;
}

ellerim bos gonlum hos
211 gün önce

1 0 ...