Nelson Elhage nelhage

My approach:

Let's use "cost" as a proxy for CO2 emissions, because within an order of magnitude I expect $1 on gas emits as much CO2 as $1 of power for a server, and I believe the bulk of the ongoing cost of operating a server is power budget.
Lifetime cost of a gas for a car: Let's estimate 100,000 miles, and 20 mpg and $4/gal. That gives us 5,000 gal and $20,000 in lifetime gas cost for a car. These numbers all feel pessimistic so we're maybe high.
A beefy server in AWS or GCP costs something like $1/hr, probably more for the really big ones. So in order to get to $20,000/run, we need 20,000 instance-hours. Let's ballpark a large training run at 1 day, so that's ~800 instances for one day. That feels within the realm of the numbers I've seen in papers.

Conclusion: Entirely plausible. Other conclusion: Lifetime cost of gasoline for a car is (in round numbers) the same as the cost of a new car. I hadn't realized they were so close. Other other conclusion: Now I understand why OpenAI needs billions o

	b1:
	%x1 = 1
	jmp b3
	b2:
	%x2 = 2
	jmp b3
	b3:
	%x3 = phi [b1, %x1], [b2, %x2]

	[nelhage@monolithique:~/code/alexbench]$ clang-11 -O1 -S -c -emit-llvm overflow_2.c
	[nelhage@monolithique:~/code/alexbench]$ opt-11 --opt-bisect-limit=137 -O2 -S overflow_2.ll 2>/dev/null \| opt-11 -O2 -S -o overflow_2_opt.ll
	[nelhage@monolithique:~/code/alexbench]$ cat overflow_2_opt.ll
	; ModuleID = '<stdin>'
	source_filename = "overflow_2.c"
	target datalayout = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-pc-linux-gnu"

	; Function Attrs: nofree nounwind uwtable
	define dso_local { i8*, i64 } @f1_overflow() local_unnamed_addr #0 {

	[package]
	name = "f"
	version = "0.1.0"
	authors = ["Alex Gaynor <[email protected]>"]
	edition = "2018"

	# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

	[dependencies]
	packed_simd = "0.3"

	│ intrinsics::move_val_init(&mut *dst, src) ▒
	0.90 │ lea (%rsi,%rsi,4),%rcx ▒
	0.05 │ shl $0x4,%rcx ▒
	0.11 │ mov 0xb8(%rsp),%rdx ▒
	0.80 │ mov %rdx,(%rax,%rcx,1) ▒
	1.66 │ movaps 0xd0(%rsp),%xmm0 ▒
	11.08 │ movups %xmm0,0x8(%rax,%rcx,1)

	// \
	/*
	#include <stdio.h>
	int main() {
	printf("Hello, World from C!\n");
	return 0;
	}

	#if 0
	//*/

	https://www.dropbox.com
	https://drive.google.com
	https://aws.amazon.com
	https://cloud.google.com
	https://hangouts.google.com/
	https://www.salesforce.com
	https://www.bitfinex.com
	https://www.coinbase.com/
	https://gemini.com/
	https://bitbucket.org

	#include <stdio.h>
	#include <math.h>
	#include <stdint.h>

	static float rt(float x) {
	volatile double g = static_cast<double>(x);
	return static_cast<float>(g);
	}

	int main() {

	#include <thread>
	#include <experimental/optional>
	#include <atomic>
	#include <shared_mutex>
	#include <mutex>
	#include <iostream>
	#include <vector>

	using namespace std;