Створіть коротку програму на C, яка займе безглуздо довгий час для компіляції з gcc. Записи будуть оцінені тимчасовим складанням, а потім відніманням часу компіляції еталонної програми.
Правила
- Будь-яка функція мови C або розширення gcc
- gcc 4.2.1
Створіть коротку програму на C, яка займе безглуздо довгий час для компіляції з gcc. Записи будуть оцінені тимчасовим складанням, а потім відніманням часу компіляції еталонної програми.
Правила
Відповіді:
#define a "xxxxxxxxxxx"
#define b a a a a a a a
#define c b b b b b b b
#define d c c c c c c c
#define e d d d d d d d
#define f e e e e e e e
#define g f f f f f f f
#define h g g g g g g g
#define i h h h h h h h
#define j i i i i i i i
z=j;
main(){char*z=j;}
щоб зробити це дійсною програмою c.
/Zm
би це
І відповідь Чарлі, і моя попередня робота працювали над принципом, щоб дозволити попередньому процесору написати багато коду, але вони в основному здійснюють сам попередній процесор, лексеру (гарна ідея, оскільки цей крок традиційно повільний) та парсер. Шахта також намагається відпрацьовувати кроки оптимізації та генерації коду, але це явно не надто багато.
Розмірковуючи про те, як працює типовий компілятор c, я зрозумів, що ми не давали коду, пов'язаному з таблицею символів, нічого робити. Цей запис є спробою виправити це. Він повинен нагадувати основну орієнтацію на об'єкти в реалізації c, але не робить нічого цікавого: просто використовує техніку розширення перед процесором для декларування та тривіально (і неправильно) ініціалізує купу об’єктів. Об'єкт, що використовує складні типи, на багатьох рівнях сфери застосування, тіняючи один одного на різних видаленнях. Слід надати таблиці символів справжню роботу.
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
// Exercise the symbol table mechanism of the compiler in an effort to
// take a unreasonable about of time compiling
#define PTR(T) T*
#define CONST(T) T const
#define FUNC(NAME,RTYPE,ARG) RTYPE NAME(ARG)
#define FPTR(NAME,RTYPE,ARG) FUNC((*NAME),RTYPE,ARG)
// Forward decalration of repeated OO method pointers
typedef void* (*cctor_ptr)(void*this, void*that, ...);
typedef void* (*dtor_ptr)(void*this);
// Assumes three var-args: sizeof(payload type), cctor, dtor
void* default_ctor(void*this, ...){
// Pull in variadac bits
va_list list;
va_start(list,this);
int size=va_arg(list,int);
cctor_ptr cctor=va_arg(list,cctor_ptr);
dtor_ptr dtor=va_arg(list,dtor_ptr);
va_end(list);
// process
if (!this) this = malloc(size);
if (this) {
memset(this,size,0);
/* various dodges to install the cctor and dtor in the write places */
}
return this;
}
// Copies the payload from that to this;
void* default_cctor(void*restrict this, void* restrict that, ...){
// Pull in variadac bits
va_list list;
va_start(list,that);
int size=va_arg(list,int);
cctor_ptr cctor=va_arg(list,cctor_ptr);
dtor_ptr dtor=va_arg(list,dtor_ptr);
va_end(list);
// process
if (!this) this = malloc(size);
if (this) {
memcpy(this,that,size);
/* various dodges to install the cctor and dtor in the write places */
}
return this;
}
// Assumes that his was allocated with malloc, does not use varargs
void* default_dtor(void*this, ...){
free(this);
return NULL;
};
#define DECLARE_STRUCT(N) struct S##N##_s
#define TYPEDEF_ACCESSOR(N,T) typedef FPTR(f##N##_ptr,CONST(PTR(T)),PTR(CONST(struct S##N##_s)))
#define TYPEDEF_STRUCT(N,T) typedef struct S##N##_s {PTR(T)p; cctor_ptr cctor; dtor_ptr dtor; f##N##_ptr f##N;} S##N
#define OO_STRUCT(N,T) DECLARE_STRUCT(N); TYPEDEF_ACCESSOR(N,T); TYPEDEF_STRUCT(N,T)
OO_STRUCT(1,char);
OO_STRUCT(2,int);
OO_STRUCT(3,double*);
OO_STRUCT(4,S3);
OO_STRUCT(5,S4);
OO_STRUCT(6,S5);
OO_STRUCT(7,S6);
OO_STRUCT(8,S7);
#define SUBSCOPE(A) { \
S1*A##1=default_ctor(NULL,sizeof(char),default_cctor,default_dtor); \
S2 A##2; default_ctor(&A##2,sizeof(int),default_cctor,default_dtor); \
S2*A##3=default_ctor(NULL,sizeof(double*),default_cctor,default_dtor); \
S8 A##5; default_ctor(&A##5,sizeof(S4),default_cctor,default_dtor); \
S6 A##6; default_ctor(&A##6,sizeof(S5),default_cctor,default_dtor); \
S8*A##8=default_ctor(NULL,sizeof(S7),default_cctor,default_dtor); \
}
#define SUBSCOPE2(A,B) { \
S2*B##5=default_ctor(NULL,sizeof(S4),default_cctor,default_dtor); \
S4 A##7; default_ctor(&A##7,sizeof(S6),default_cctor,default_dtor); \
SUBSCOPE(A) SUBSCOPE(B); \
}
#define SUBSCOPE6(A,B,C) { \
S2*A##3=default_ctor(NULL,sizeof(double*),default_cctor,default_dtor); \
S2 B##2; default_ctor(&B##2,sizeof(int),default_cctor,default_dtor); \
S4*C##4=NULL; \
SUBSCOPE2(A,C) SUBSCOPE2(B,C) SUBSCOPE2(A,B); \
}
#define SUBSCOPE24(A,B,C,D) { \
S1*D##1=default_ctor(NULL,sizeof(char),default_cctor,default_dtor); \
S2 C##2; default_ctor(&C##2,sizeof(int),default_cctor,default_dtor); \
S2*B##3=default_ctor(NULL,sizeof(double*),default_cctor,default_dtor); \
S4 A##4; default_ctor(&A##4,sizeof(S3),default_cctor,default_dtor); \
SUBSCOPE6(A,B,C) SUBSCOPE6(A,B,D) SUBSCOPE6(A,C,D) SUBSCOPE6(B,C,D); \
}
#define SUBSCOPE120(A,B,C,D,E) { \
S5*A##5=default_ctor(NULL,sizeof(S4),default_cctor,default_dtor); \
S6*A##6=default_ctor(NULL,sizeof(S5),default_cctor,default_dtor); \
S8 A##8; default_ctor(&A##8,sizeof(S7),default_cctor,default_dtor); \
SUBSCOPE24(A,B,C,D) SUBSCOPE24(A,B,C,E) SUBSCOPE24(A,B,D,E); \
SUBSCOPE24(A,C,D,E) SUBSCOPE24(B,C,D,E); \
}
#define SUBSCOPE720(A,B,C,D,E,F) { \
S5 A##5; default_ctor(&A##5,sizeof(S4),default_cctor,default_dtor); \
S6 A##6; default_ctor(&A##6,sizeof(S5),default_cctor,default_dtor); \
S8*A##8=default_ctor(NULL,sizeof(S7),default_cctor,default_dtor); \
SUBSCOPE120(A,B,C,D,E) SUBSCOPE120(A,B,C,D,F) SUBSCOPE120(A,B,C,E,F); \
SUBSCOPE120(A,B,D,E,F) SUBSCOPE120(A,C,D,E,F) SUBSCOPE120(B,C,D,E,F); \
}
int main(){
S4 s4;
SUBSCOPE720(A,B,C,D,E,F)
}
Час компіляції на моїй машині перевищує 4 секунди -O3
і більше 1 секунди без оптимізації.
Очевидно, наступним кроком буде завершення впровадження OO для класів BCD і повторне виконання пі обчислень, використовуючи його, щоб я отримав обидва ефекти важко.
Ось ця тема розширення експоненціально-препроцесора, яка робить щось мінімально цікаве: обчислює два наближення до pi методами рядів і порівнює як зі значенням, так math.h
і зі звичайним закликом.
Безумовно.
#include <math.h>
#include <stdio.h>
// Some random bits we'll need
#define MINUSONODD(n) (n%2?-1:+1)
#define TWON(n) (2*(n))
#define NPLUSONE(n) ((n)+1)
#define TWONPLUSONE(n) NPLUSONE(TWON(n))
#define FACT(n) (tgamma(NPLUSONE(n)))
// The Euler series
// 2^(2n) * (n!)^2 z^(2n+1)
// atan(z) = \sum_n=0^\infty --------------- * ---------------
// (2n+1)! (1 + z^2)^(n+1)
#define TERMEULER(n,z) (pow(2,TWON(n))* \
FACT(n)*FACT(n)* \
pow((z),TWONPLUSONE(n))/ \
FACT(TWONPLUSONE(n)) / \
pow((1+z*z),NPLUSONE(n)) )
// The naive version
// (-1)^n * z^(2n+1)
// atan(z) = \sum_n=0^\infty -----------------
// 2n + 1
#define TERMNAIVE(n,z) (MINUSONODD(n)*pow(z,TWONPLUSONE(n))/TWONPLUSONE(n))
// Define a set of bifruncations of the sum
#define N2TERMS(n,z,ALG) (TERM##ALG(TWON(n),(z)) + TERM##ALG(TWONPLUSONE(n),(z)))
#define N4TERMS(n,z,ALG) (N2TERMS(TWON(n),(z),ALG)+N2TERMS(TWONPLUSONE(n),(z),ALG))
#define N8TERMS(n,z,ALG) (N4TERMS(TWON(n),(z),ALG)+N4TERMS(TWONPLUSONE(n),(z),ALG))
#define N16TERMS(n,z,ALG) (N8TERMS(TWON(n),(z),ALG)+N8TERMS(TWONPLUSONE(n),(z),ALG))
#define N32TERMS(n,z,ALG) (N16TERMS(TWON(n),(z),ALG)+N16TERMS(TWONPLUSONE(n),(z),ALG))
// Sum the fist 32*2+16 = 80 terms of a series...
#define PARTIALSUM(z,ALG) N32TERMS(0,(z),ALG)+N32TERMS(1,(z),ALG)+N16TERMS(4,(z),ALG)
int main(void){
const double PI_TRAD = 4.0L * atan(1.0);
const double PI_NAIVE = 4.0L * PARTIALSUM(0.999999L,NAIVE);
const double PI_EULER = 4.0L * PARTIALSUM(0.999999L,EULER);
printf("pi (math.h) = %10.8f\n",M_PI);
printf("pi (trad.) = %10.8f\n",PI_TRAD);
printf("pi (NAIVE) = %10.8f\n",PI_NAIVE);
printf("pi (EULER) = %10.8f\n",PI_EULER);
}
Передбачає, що ви використовуєте gcc
та glibc
можете, а також не можете працювати з іншими домовленостями. Для процесора потрібно приблизно 1,0-1,1 секунди (за оцінкою time (1)
) для роботи на -03
1 моєму 2,4 ГГц Intel Core 2 Duo MacBook. Компіляція за замовчуванням займає приблизно 0,4 секунди часу процесора.
На жаль, я не можу заставити gcc оцінити pow
або tgamma
під час компіляції, що справді допоможе.
Коли ви запускаєте його, вихід:
pi (math.h) = 3.14159265
pi (trad.) = 3.14159265
pi (NAIVE) = 3.11503599
pi (EULER) = 3.14159065
що показує, як повільно сходяться наївні серії.
1 Щоб отримати якомога більше постійного складання та усунення субвиразів.