cat /etc/os-release
uname -r
lscpu | grep -E "(Model name|CPU\(s\):|Core\(s\) per socket|Thread\(s\) per core)"
free -h
df -h

dnf install -y gcc gcc-c++ make cmake autoconf automake binutils
gcc --version
g++ --version
make --version

cat > hello.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>

#define ARRAY_SIZE 1000000

int main() {
    int *array = malloc(ARRAY_SIZE * sizeof(int));
    for (int i = 0; i < ARRAY_SIZE; i++) {
        array[i] = i * 2;
    }
    
    long long sum = 0;
    for (int i = 0; i < ARRAY_SIZE; i++) {
        sum += array[i];
    }
    
    printf("Sum: %lld\n", sum);
    free(array);
    return 0;
}
EOF

for opt in O0 O1 O2 O3 Os; do
    echo "Testing optimization level: $opt"
    time gcc -$opt hello.c -o hello_$opt
    ls -lh hello_$opt
    echo "---"
done

mkdir -p project/src project/include
cat > project/include/utils.h << 'EOF'
#ifndef UTILS_H
#define UTILS_H

void process_data(int *data, int size);
int calculate_sum(int *data, int size);

#endif
EOF

cat > project/src/utils.c << 'EOF'
#include "utils.h"

void process_data(int *data, int size) {
    for (int i = 0; i < size; i++) {
        data[i] = data[i] * 2 + 1;
    }
}

int calculate_sum(int *data, int size) {
    int sum = 0;
    for (int i = 0; i < size; i++) {
        sum += data[i];
    }
    return sum;
}
EOF

cat > project/src/main.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include "utils.h"

#define DATA_SIZE 1000000

int main() {
    int *data = malloc(DATA_SIZE * sizeof(int));
    for (int i = 0; i < DATA_SIZE; i++) {
        data[i] = i;
    }
    
    process_data(data, DATA_SIZE);
    int sum = calculate_sum(data, DATA_SIZE);
    
    printf("Processed sum: %d\n", sum);
    free(data);
    return 0;
}
EOF

cat > project/Makefile << 'EOF'
CC = gcc
CFLAGS = -O2 -I./include
SRCDIR = src
OBJDIR = obj
SOURCES = $(wildcard $(SRCDIR)/*.c)
OBJECTS = $(SOURCES:$(SRCDIR)/%.c=$(OBJDIR)/%.o)
TARGET = main

$(TARGET): $(OBJECTS)
        $(CC) $(CFLAGS) -o $@ $^

$(OBJDIR)/%.o: $(SRCDIR)/%.c
        @mkdir -p $(OBJDIR)
        $(CC) $(CFLAGS) -c $< -o $@

clean:
        rm -rf $(OBJDIR) $(TARGET)

.PHONY: clean
EOF

cd project
time make
cd ..

mkdir -p parallel_build_test && cd parallel_build_test && cat > hello.c << 'EOF'
#include <stdio.h>
int main() { printf("Hello, Parallel Build!\n"); return 0; }
EOF
cat > Makefile << 'EOF'
CC=gcc
CFLAGS=-O2
TARGET=hello
SOURCES=hello.c
$(TARGET): $(SOURCES)
        $(CC) $(CFLAGS) -o $(TARGET) $(SOURCES)
clean:
        rm -f $(TARGET)
.PHONY: clean
EOF
echo "=== Parallel Build Performance Test ==="
for jobs in 1 2 4 8; do
    echo "Testing with $jobs parallel job(s):"
    make clean >/dev/null 2>&1
    { time make -j$jobs >/dev/null 2>&1; } 2>&1 | grep real
    echo "---"
done
echo "Program output:"
gcc -O2 hello.c -o hello && ./hello

cd /tmp && rm -rf huge_test && mkdir huge_test && cd huge_test && cat > Makefile << 'EOF'
CC=g++
CFLAGS=-O0 -std=c++11
TARGET=app
SOURCES=$(wildcard *.cpp)
OBJS=$(SOURCES:.cpp=.o)
$(TARGET): $(OBJS)
        $(CXX) -o $(TARGET) $(OBJS)
%.o: %.cpp
        $(CXX) $(CFLAGS) -c $< -o $@
clean:
        rm -f $(TARGET) *.o
.PHONY: clean
EOF
for i in {1..3000}; do cat > file$i.cpp << EOF
#include<vector>
#include<algorithm>
template<typename T>class Container{std::vector<T>data;public:void add(T v){data.push_back(v);}T sum(){T s=0;for(auto&v:data)s+=v;return s;}void sort(){std::sort(data.begin(),data.end());}};
void func$i(){Container<int>c;for(int i=0;i<100;i++)c.add(i*$i);auto s=c.sum();c.sort();}
EOF
done
cat > main.cpp << 'EOF'
int main(){return 0;}
EOF
echo "=== 3000 C++ Files Test ==="
for jobs in 1 2 4 8; do
    echo -n "Jobs $jobs: "
    make clean >/dev/null 2>&1
    { time make -j$jobs >/dev/null 2>&1; } 2>&1 | grep real | awk '{print $2}'
done

cat > performance_test.c << 'EOF'
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define MATRIX_SIZE 500

void matrix_multiply(double A[MATRIX_SIZE][MATRIX_SIZE], 
                    double B[MATRIX_SIZE][MATRIX_SIZE],
                    double C[MATRIX_SIZE][MATRIX_SIZE]) {
    for (int i = 0; i < MATRIX_SIZE; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            C[i][j] = 0;
            for (int k = 0; k < MATRIX_SIZE; k++) {
                C[i][j] += A[i][k] * B[k][j];
            }
        }
    }
}

int main() {
    double A[MATRIX_SIZE][MATRIX_SIZE];
    double B[MATRIX_SIZE][MATRIX_SIZE];
    double C[MATRIX_SIZE][MATRIX_SIZE];
    
    srand(time(NULL));
    for (int i = 0; i < MATRIX_SIZE; i++) {
        for (int j = 0; j < MATRIX_SIZE; j++) {
            A[i][j] = (double)rand() / RAND_MAX;
            B[i][j] = (double)rand() / RAND_MAX;
        }
    }
    
    clock_t start = clock();
    matrix_multiply(A, B, C);
    clock_t end = clock();
    
    double time_used = ((double)(end - start)) / CLOCKS_PER_SEC;
    printf("Matrix multiplication time: %.3f seconds\n", time_used);
    
    return 0;
}
EOF

for opt in O0 O1 O2 O3; do
    echo "Compiling with -$opt optimization:"
    gcc -$opt performance_test.c -o perf_$opt
    echo "Execution performance:"
    time ./perf_$opt
    echo "---"
done