Let's Encrypt обслуживает почти 30% доменов

Просто пользуйтесь тестовыми серверами во время начальной настройки, там лимиты во много раз выше: certbot --test-cert.

Как заставить компилятор C/C++ генерировать плохой код

Ага. Исправил.

Как заставить компилятор C/C++ генерировать плохой код

Без /m:

С указателями:

Скрытый текст

   0x0000000000400a7a <+426>:	add    $0x4,%rbx
   0x0000000000400a7e <+430>:	cmp    $0x28,%rbx
   0x0000000000400a82 <+434>:	jne    0x400a50 <main()+384>
   0x0000000000400a84 <+436>:	lea    0x10(%r12),%rax
   0x0000000000400a89 <+441>:	lea    0x10(%r13),%rdx
   0x0000000000400a8d <+445>:	cmp    %rax,%r13
   0x0000000000400a90 <+448>:	setae  %cl
   0x0000000000400a93 <+451>:	cmp    %rdx,%r12
   0x0000000000400a96 <+454>:	setae  %dl
   0x0000000000400a99 <+457>:	or     %dl,%cl
   0x0000000000400a9b <+459>:	je     0x400b60 <main()+656>
   0x0000000000400aa1 <+465>:	cmp    %rax,%rbp
   0x0000000000400aa4 <+468>:	lea    0x10(%rbp),%rax
   0x0000000000400aa8 <+472>:	setae  %dl
   0x0000000000400aab <+475>:	cmp    %rax,%r12
   0x0000000000400aae <+478>:	setae  %al
   0x0000000000400ab1 <+481>:	or     %al,%dl
   0x0000000000400ab3 <+483>:	je     0x400b60 <main()+656>
   0x0000000000400ab9 <+489>:	movdqu 0x0(%rbp),%xmm1
   0x0000000000400abe <+494>:	lea    0x20(%r12),%rax
   0x0000000000400ac3 <+499>:	mov    $0x2,%edx
   0x0000000000400ac8 <+504>:	movdqu 0x0(%r13),%xmm0
   0x0000000000400ace <+510>:	paddd  %xmm1,%xmm0
   0x0000000000400ad2 <+514>:	movdqu %xmm0,(%r12)
   0x0000000000400ad8 <+520>:	movdqu 0x10(%rbp),%xmm1
   0x0000000000400add <+525>:	add    $0x20,%rbp
   0x0000000000400ae1 <+529>:	movdqu 0x10(%r13),%xmm0
   0x0000000000400ae7 <+535>:	add    $0x20,%r13
   0x0000000000400aeb <+539>:	paddd  %xmm1,%xmm0
   0x0000000000400aef <+543>:	movdqu %xmm0,0x10(%r12)
   0x0000000000400af6 <+550>:	sub    $0x1,%edx
   0x0000000000400af9 <+553>:	lea    0x4(,%rdx,4),%rsi
   0x0000000000400b01 <+561>:	xor    %edx,%edx
   0x0000000000400b03 <+563>:	nopl   0x0(%rax,%rax,1)
   0x0000000000400b08 <+568>:	mov    0x0(%rbp,%rdx,1),%ecx
   0x0000000000400b0c <+572>:	add    0x0(%r13,%rdx,1),%ecx
   0x0000000000400b11 <+577>:	mov    %ecx,(%rax,%rdx,1)
   0x0000000000400b14 <+580>:	add    $0x4,%rdx

С индексами:

Скрытый текст

   0x0000000000400962 <+146>:	add    $0x4,%rbx
   0x0000000000400966 <+150>:	cmp    $0x28,%rbx
   0x000000000040096a <+154>:	jne    0x400938 <main()+104>
   0x000000000040096c <+156>:	lea    0x10(%rbp),%rax
   0x0000000000400970 <+160>:	lea    0x10(%r12),%rdx
   0x0000000000400975 <+165>:	cmp    %rax,%r12
   0x0000000000400978 <+168>:	setae  %cl
   0x000000000040097b <+171>:	cmp    %rdx,%rbp
   0x000000000040097e <+174>:	setae  %dl
   0x0000000000400981 <+177>:	or     %dl,%cl
   0x0000000000400983 <+179>:	je     0x400b54 <main()+644>
   0x0000000000400989 <+185>:	cmp    %rax,%r13
   0x000000000040098c <+188>:	lea    0x10(%r13),%rax
   0x0000000000400990 <+192>:	setae  %dl
   0x0000000000400993 <+195>:	cmp    %rax,%rbp
   0x0000000000400996 <+198>:	setae  %al
   0x0000000000400999 <+201>:	or     %al,%dl
   0x000000000040099b <+203>:	je     0x400b54 <main()+644>
   0x00000000004009a1 <+209>:	movdqu 0x0(%r13),%xmm1
   0x00000000004009a7 <+215>:	mov    $0x2,%edx
   0x00000000004009ac <+220>:	mov    $0x8,%eax
   0x00000000004009b1 <+225>:	movdqu (%r12),%xmm0
   0x00000000004009b7 <+231>:	paddd  %xmm1,%xmm0
   0x00000000004009bb <+235>:	movdqu %xmm0,0x0(%rbp)
   0x00000000004009c0 <+240>:	movdqu 0x10(%r13),%xmm1
   0x00000000004009c6 <+246>:	movdqu 0x10(%r12),%xmm0
   0x00000000004009cd <+253>:	paddd  %xmm1,%xmm0
   0x00000000004009d1 <+257>:	movdqu %xmm0,0x10(%rbp)
   0x00000000004009d6 <+262>:	shl    $0x2,%rax
   0x00000000004009da <+266>:	sub    $0x1,%edx
   0x00000000004009dd <+269>:	lea    0x4(,%rdx,4),%rsi
   0x00000000004009e5 <+277>:	add    %rax,%r13
   0x00000000004009e8 <+280>:	add    %rax,%r12
   0x00000000004009eb <+283>:	xor    %edx,%edx
   0x00000000004009ed <+285>:	add    %rbp,%rax
   0x00000000004009f0 <+288>:	mov    0x0(%r13,%rdx,1),%ecx
   0x00000000004009f5 <+293>:	add    (%r12,%rdx,1),%ecx
   0x00000000004009f9 <+297>:	mov    %ecx,(%rax,%rdx,1)
   0x00000000004009fc <+300>:	add    $0x4,%rdx

Как заставить компилятор C/C++ генерировать плохой код

А, ну да. Тогда получается, что последняя команда — jne, и вопpос «где цикл?» отпадает сам собой.

Как заставить компилятор C/C++ генерировать плохой код

Каким образом запись a[i] может изменить значение N?

Как заставить компилятор C/C++ генерировать плохой код

В данном примере N = 10. Код полон, это всё, что относится к циклу.

Как заставить компилятор C/C++ генерировать плохой код

Запустил gdb и дизассемблиpовал с ключом /m.

Как заставить компилятор C/C++ генерировать плохой код

Тогда извините.

Как заставить компилятор C/C++ генерировать плохой код

Ну очевидно же — оптимизироваться будет не так плохо, как глобальная, но хуже, чем локальная. Если она private и к ней обращается только один метод — случай аналогичен локальной (не уверен, что любой компилятор это поймёт, но вышеупомянутый gcc понял).

Как заставить компилятор C/C++ генерировать плохой код

Ну, начнём с того, что компиляторы GCC и ICC есть под Linux, а MS и Borland — нету. Взглянуть на их результаты мне тоже было бы любопытно.

Как заставить компилятор C/C++ генерировать плохой код

Тогда одинаково. Но на практике длина массива далеко не всегда является константой, и локальная переменная создаёт больший простор для оптимизации.

Как заставить компилятор C/C++ генерировать плохой код

Пробуем на gcc 4.7.2 c -O2:

Скрытый текст

   0x00000000004008d6 <+6>:	mov    $0xa,%ebx
   0x00000000004008db <+11>:	sub    $0x8,%rsp
   0x00000000004008df <+15>:	nop
16		{
17			int N = 10;
18			for (int i=0; i<N; i++)
   0x00000000004008e5 <+21>:	sub    $0x1,%ebx
   0x00000000004008e8 <+24>:	jne    0x4008e0 <main()+16>
19			{
20				doSomething();
   0x00000000004008e0 <+16>:	callq  0x400b90 <doSomething()>
21			}

Скрытый текст

24			for (int i=0; i<globalN; i++)
   0x00000000004008ea <+26>:	mov    0x2009d0(%rip),%eax        # 0x6012c0 <globalN>
   0x00000000004008f0 <+32>:	xor    %ebx,%ebx
   0x00000000004008f2 <+34>:	test   %eax,%eax
   0x00000000004008f4 <+36>:	jle    0x400910 <main()+64>
   0x00000000004008f6 <+38>:	nopw   %cs:0x0(%rax,%rax,1)
   0x0000000000400905 <+53>:	add    $0x1,%ebx
   0x0000000000400908 <+56>:	cmp    %ebx,0x2009b2(%rip)        # 0x6012c0 <globalN>
   0x000000000040090e <+62>:	jg     0x400900 <main()+48>
25			{
26				doSomething();
   0x0000000000400900 <+48>:	callq  0x400b90 <doSomething()>

27			}

Чувствуете разницу? В случае с локальной переменной вообще нет обращений к памяти.

Как заставить компилятор C/C++ генерировать плохой код

В определении действительно была ошибка. Исправил. Почему вы не написали в личку?

Как заставить компилятор C/C++ генерировать плохой код

Да, вы правы. Я проверил — оба варианта действительно вектоpизуются. Только код получается немного разным:

Скрытый текст

44			for (int i=0; i<N; i++)
   0x0000000000400828 <+536>:	cmp    %rsi,%rdx
   0x000000000040082b <+539>:	jne    0x400818 <main()+520>
   0x000000000040082d <+541>:	lea    0x28(%r12),%rbx
45			{
46				*a++ = *b++ + *c++;
   0x00000000004007c9 <+441>:	movdqu 0x0(%rbp),%xmm1
   0x00000000004007ce <+446>:	lea    0x20(%r12),%rax
   0x00000000004007d3 <+451>:	mov    $0x2,%edx
   0x00000000004007d8 <+456>:	movdqu 0x0(%r13),%xmm0
   0x00000000004007de <+462>:	paddd  %xmm1,%xmm0
   0x00000000004007e2 <+466>:	movdqu %xmm0,(%r12)
   0x00000000004007e8 <+472>:	movdqu 0x10(%rbp),%xmm1
   0x00000000004007ed <+477>:	add    $0x20,%rbp
   0x00000000004007f1 <+481>:	movdqu 0x10(%r13),%xmm0
   0x00000000004007f7 <+487>:	add    $0x20,%r13
   0x00000000004007fb <+491>:	paddd  %xmm1,%xmm0
   0x00000000004007ff <+495>:	movdqu %xmm0,0x10(%r12)
   0x0000000000400818 <+520>:	mov    0x0(%rbp,%rdx,1),%ecx
   0x000000000040081c <+524>:	add    0x0(%r13,%rdx,1),%ecx
   0x0000000000400821 <+529>:	mov    %ecx,(%rax,%rdx,1)
   0x0000000000400824 <+532>:	add    $0x4,%rdx
47			}

Скрытый текст

20			for (int i=0; i<N; i++)
   0x00000000004006bc <+172>:	mov    $0x8,%eax
   0x0000000000400710 <+256>:	cmp    %rsi,%rdx
   0x0000000000400713 <+259>:	jne    0x400700 <main()+240>
21			{
22				a[i] = b[i]+c[i];
   0x00000000004006b1 <+161>:	movdqu 0x0(%r13),%xmm1
   0x00000000004006b7 <+167>:	mov    $0x2,%edx
   0x00000000004006c1 <+177>:	movdqu (%r12),%xmm0
   0x00000000004006c7 <+183>:	paddd  %xmm1,%xmm0
   0x00000000004006cb <+187>:	movdqu %xmm0,0x0(%rbp)
   0x00000000004006d0 <+192>:	movdqu 0x10(%r13),%xmm1
   0x00000000004006d6 <+198>:	movdqu 0x10(%r12),%xmm0
   0x00000000004006dd <+205>:	paddd  %xmm1,%xmm0
   0x00000000004006e1 <+209>:	movdqu %xmm0,0x10(%rbp)
   0x0000000000400700 <+240>:	mov    0x0(%r13,%rdx,1),%ecx
   0x0000000000400705 <+245>:	add    (%r12,%rdx,1),%ecx
   0x0000000000400709 <+249>:	mov    %ecx,(%rax,%rdx,1)
   0x000000000040070c <+252>:	add    $0x4,%rdx
23			}

Насколько я понимаю, второй вариант всё-таки будет эффективнее.

Как заставить компилятор C/C++ генерировать плохой код

Это точно! Но дать компилятору возможность испортить код может вообще любой программист, как бы хорош он ни был.