# -*- coding: utf-8 -*-
import numpy
import pylab
import matplotlib.pyplot as plt
import matplotlib.colors
import itertools
import re
import hashlib
from string import ascii_lowercase

markerTypes=[',', '+', '.', '^', 'v', '<', '>', 'o', '*', '1', '2', '3', '4', '8', 's', 'p', 'h', 'H', 'x', 'X', 'D', 'd', '|', '_']
#for c in ascii_lowercase:
#	markerTypes.append('$%s$' % c)
#markerColors=('r', 'g', 'b')
markerColors=('r')

def get_marker(proc_id):
	hash_object = hashlib.md5(proc_id.encode('utf-8'))
	hash = int(hash_object.hexdigest(), 16)
	return markerTypes[ hash % len(markerTypes) ]

def plotCpuPassmark():
	cpuTable = numpy.genfromtxt('cpu_table.dat', dtype=("|U10", float, int, float, float), names=True, delimiter='\t')
	plt.subplot(1,1,0)
	plt.subplots_adjust(bottom = 0.1)
	markersCycler = itertools.cycle(itertools.product(markerTypes, markerColors))
	labels = cpuTable['id']
	x = cpuTable['clock'] * cpuTable['num_cores']
	y = cpuTable['cpumark']
	markerSize = 50
	color = 'b'
	for label, x1, y1 in zip(labels, x, y):
		if  y1 <= 0.0:
			continue # no passmark available fo this data
		generation=label[-1]
		if generation == '2':
			color = 'b'
		else:
			color = 'r'			
		marker = markersCycler.next()
		plt.scatter( x1, y1, color = color, s = markerSize, marker = marker[0], label = label)	
	plt.xlabel(u'theoretical cpu speed [core.GHz]')
	plt.ylabel(u'passmark [?]')
	plt.title(u'comparison between cpu theoretical and effective speed')
	plt.xlim( xmin = 0.0 )
	plt.ylim( ymin = 0.0 )
	plt.legend(bbox_to_anchor=(0.2, 1.0))
	#plt.legend()
	plt.draw()
	plt.show()


def get_proc_architecture(proc_id):
	if re.match('core-i[357]-8[0-9][0-9][0-9][ktbuh]', proc_id):
		return 'coffeelake'
	elif re.match('Silver-[0-9]2[0-9][0-9]', proc_id):
		return 'cascadelake'
	elif re.match('Gold-[0-9]2[0-9][0-9]', proc_id):
		return 'cascadelake'
	elif re.match('Platinum-[0-9]2[0-9][0-9]', proc_id):
		return 'cascadelake'
	elif re.match('Gold-[0-9]1[0-9][0-9]', proc_id):
		return 'skylake'
	elif re.match('Platinum-[0-9]1[0-9][0-9]', proc_id):
		return 'skylake'
	elif re.match('E5-26[0-9][0-9][LWA]*v4', proc_id):
		return 'broadwell'
	elif re.match('E5-26[0-9][0-9][LWA]*v3', proc_id):
		return 'haswell'
	elif re.match('E5-26[0-9][0-9][LWA]*v2', proc_id):
		return 'ivy bridge'
	elif re.match('E5-26[0-9][0-9][LWA]*', proc_id):
		return 'sandy bridge'
	elif re.match('X56[0-9][0-9]', proc_id):
		return 'gulftown'
	elif re.match('X55[0-9][0-9]', proc_id):
		return 'gainestown'
	elif re.match('E54[0-9][0-9]', proc_id):
		return 'harpertown'
	elif re.match('51[0-9][0-9]', proc_id):
		return 'woodcrest'
	else:
		assert False
	
def get_proc_arch_transistor_size(proc_arch): 
	return {
		'woodcrest':65,
		'harpertown':45,
		'gainestown':45,
		'gulftown':32,
		'sandy bridge':32,
		'ivy bridge':22,
		'haswell':22,
		'broadwell':14,
		'skylake':14,
		'coffeelake':14,
		'cascadelake':14
		}[get_proc_architecture(proc_arch)]

def simd_id_to_dp_flops_per_cycle(simd_id):
	"""
	:param str simd_id: eg 'avx2'
	
	"""
	# from https://stackoverflow.com/questions/15655835/flops-per-cycle-for-sandy-bridge-and-haswell-sse2-avx-avx2
	# Intel Core 2 and Nehalem:
	# 
	#     4 DP FLOPs/cycle: 2-wide SSE2 addition + 2-wide SSE2 multiplication
	#     8 SP FLOPs/cycle: 4-wide SSE addition + 4-wide SSE multiplication
	# 
	# Intel Sandy Bridge/Ivy Bridge:
	# 
	#     8 DP FLOPs/cycle: 4-wide AVX addition + 4-wide AVX multiplication
	#     16 SP FLOPs/cycle: 8-wide AVX addition + 8-wide AVX multiplication
	# 
	# Intel Haswell/Broadwell/Skylake/Kaby Lake:
	# 
	#     16 DP FLOPs/cycle: two 4-wide FMA (fused multiply-add) instructions
	#     32 SP FLOPs/cycle: two 8-wide FMA (fused multiply-add) instructions

	return {	
		'sse4.1':4,
		'sse4.2':4,
		'avx':8,
		'avx2':16,
		'avx-512':16,
		}[simd_id]
	
def get_simd_id(proc_arch):
	"""
		:param str proc_arch: eg 'broadwell'
		:return str: eg 'sse4'
	"""
	return {
		'woodcrest':'sse4.1',
		'harpertown':'sse4.1',
		'gainestown':'sse4.2',
		'gulftown':'sse4.2',
		'sandy bridge':'avx',
		'ivy bridge':'avx',
		'haswell':'avx2',
		'broadwell':'avx2',
		'skylake':'avx-512',
		'cascadelake':'avx-512',
		'coffeelake':'avx2'
		}[proc_arch]

def num_dp_flop_per_cycle(proc_id):
	proc_arch = get_proc_architecture(proc_id)
	simd_id = get_simd_id(proc_arch)
	num_simd_per_core = 1
	if proc_arch == 'skylake' or proc_arch == 'cascadelake':
	    # from https://en.wikipedia.org/wiki/List_of_Intel_Xeon_microprocessors : Xeon Platinum, Gold 61XX, and Gold 5122 have two AVX-512 FMA units per core; Xeon Gold 51XX (except 5122), Silver, and Bronze have a single AVX-512 FMA unit per core
		if re.match('Gold-5122', proc_id):
			num_simd_per_core = 2
		if re.match('Gold-61[0-9][0-9]', proc_id):
			num_simd_per_core = 2
		if re.match('Gold-62[0-9][0-9]', proc_id):
			num_simd_per_core = 2
	dp_flops_per_cycle = num_simd_per_core * simd_id_to_dp_flops_per_cycle(simd_id)
	print(proc_id, dp_flops_per_cycle)
	return dp_flops_per_cycle

def get_system_base_price( host_id ):
	# for r730 on 06/10/2016
	#   (x: price without procs, p1 : price of e5-2603v4, p2: price of e5-2609v4)
	#   we want to know x, given dell's web site, where we can get the price for multiple proc but not 0
	#   x + p1 = 1014.0
	#   x + 2 * p1 = 1014.0 + 216
	#   => p1 approx= 215.5
	#   => x = 1014. - 215. = 799.0
	#   x + p2 = 1123.0
	#   => p2 = 324.0
	#   x + 2 * p2 = 1447.0
	# for r630 on 14/10/2016
	#   (x: price without procs, p2603: price of e5-2603v4, p2609: price of e5-2609v4)
	#   we want to know x, given dell's web site, where we can get the price for multiple proc but not 0
	#   x + p2603 = 948.0
	#   x + 2 * p2603 = 948.0 + 216
	#   => p2603 approx= 215.5
	#   => x = 948. - 215. = 733.0
	# verification :
	#   x + p2609 = 1057.0
	#   => p2609 = 1057-733=324.0
	#   x + 2 * p2609 = 1381.0
	# for 4xc6320 on 14/10/2016
	#   (x: price without procs, p2603: price of e5-2603v4, p2609: price of e5-2609v4)
	# x + 4 x (2 x p2620 +  p32G) =  5135 € HT
	# x + 4 x (2 x p2640 + p128G + pX520 + p5years) = 15590 € HT
	# x + 4 x (2 x p2650 + p128G + pX520 + p5years) = 17340 € HT
	# x + 4 x (2 x p2660 + p128G + pX520 + p5years) = 19490 € HT
	# by examining this and the price of processors on R630
	# - E5-2620v4 :   458€
	# - E5-2640v4 :   951€
	# - E5-2650v4 :  1209€
	# - E5-2660v4 :  1525€
	# - E5-2680v4 :  1867€
	# - E5-2690v4 :  2261€
	# I could work out that :
	# - the price of procs on c6320 is the price of procs on r630 * 85%
	# - the price of the base c6320 with 32 Go and no proc at all is 2020.6
	# - the price of the 32G to 128G upgrade is 6222.6 euros (cheaper price of 16G->128G upgrade on r630 : (1778*4 = 7112))
	# details :
	# 	>>> (19490.-17340)/8
	# 	268.75
	# 	>>> (17340.-15590)/8
	# 	218.75
	# 	>>> 218.75/258.
	# 	0.8478682170542635
	# 	>>> 268.75/316
	# 	0.8504746835443038
	# 	>>> 15590.0+((1209.0-951.0)*0.85)*8
	# 	17344.4
	# 	>>> 15590.0+((1525.0-951.0)*0.85)*8
	# 	19493.2
	#   price of 128G ram upgrade assuming that 5years guarantee costs 880€ (same as c6220),
	# 	>>> 15590.0+((458.0-951.0)*0.85)*8-210.0*4-880.0 - 5135.0
	#	6222.6
	# 	>>> 5135.0 - (458.0*0.85)*8
	# 	2020.6
	# for c4130 on 14/10/2016
	# x + 2 x E5-2640v4 + 128G + 2 * K80 + X520 + p5years = 12281€
	# x + 2 x E5-2640v4 + 128G + 4 * K80 + X520 + p5years = 19317€
	# price of a K80
	# >>> (19317.-12281)/2
	# 3518.0
	# assuming the options cost the same as for R630 (X520=210€, p5years=240€, 128G=1778€, E5-2640v4=951€), the cost of the base system is :
	# >>> 12281-951-951-1778-210-240-3518-3518
	# 1115
	# but if we integrate the X520 card so that we have a 10Gb ethernet in the base, the cost of the base system becomes :
	# >>> 1115+210
	# 1325
	# on 29/09/2017
	#   (x: price without procs, p3106: price of Bronze-3106, p6126: price of Gold6126)
	#   we want to know x, given dell's web site, where we can get the price for multiple proc but not 0
	#   x + p3106 = 1067.0
	#   x + 2 * p3106 = 1067.0 + 320.0
	#   => p3106 = 320
	#   => x = 1067.0 - 320.0 = 747.0
	# 	check if x computation is consistent with p6126
	#   x + p6126 = 2767
	#   x + 2 * p6126 = 4787.0
	#   => p6126 = 2020.0
	#   => x = 747.0 --> yes !
		
	# price of r940 (with 2x xeon gold 5215 and 32 Go DDR4 @ 2933GHz) on 09/06/2020 : 3784€
	#   (x: price without procs, p5215: price of gold-5215, p6248: price of Gold6248)
	#   p6240 = 2684
	#   p6248 = 3442
	#   p8280l = 12075
	#   x + 2 * p5215 = 3784
	#   x + 4 * p6240 = 11886   =>    x = 1150
	#   x + 4 * p6248 = 14918   =>    x = 1150
	#   x + 4 * p8280l = 49450  =>    x = 1150
	#   => p5215 = 1317   (agrees with proc price on r640)


	return {
		'c6220':4890.0,
		'r620':860.0,
		'r630':733.0,
		'r640':747.0,
		'r730':799.0,
		'r940':1150.0,
		'c6320':2020.6,
		'c4310':1325.0,
		'precision3630':449.0
		}[host_id]

def plotSystemEfficiency():

	cpuTable = numpy.genfromtxt('cpu_table.dat', dtype=("|U15", float, int, float, float, float), names=True, delimiter='\t')
	#cpuTable = numpy.genfromtxt('dell_ivybridge_table.dat', dtype=(('id', "|S10"), ('clock', float), ('num_cores', int), ('price', float, float)), names=None, delimiter='\t')
	print(type(cpuTable))
	print(cpuTable.dtype)
	print(cpuTable)
	print(cpuTable['id'])

	dellPriceTable = numpy.genfromtxt('dell_procoptions_table.dat', dtype=("|U15", "|U15", float), names=True, delimiter='\t')
	#cpuTable = numpy.genfromtxt('dell_ivybridge_table.dat', dtype=(('id', "|S10"), ('clock', float), ('num_cores', int), ('price', float, float)), names=None, delimiter='\t')

	#for (x, y) in clusters:
	serverBasePowerConsumption = 100.0 # rough estimation in watts
	def GHzToMHz( frequency ):
		return frequency * 1000.0
		
		
	
	kWHPrice = 0.07 * 1.5
	containerLifetime = 7.0 # in years
	powerUsageEfficiency = 0.5

	ramUpgradePrice128Gb = {
		'c6220':3520.0,
		'r620':2010.0, 
		'r630':1778.0,
		'r640':1780.0,
		'r730':1778.0,
		'r940':960.0,   # 32 Gb 2933 MHz RDIMM : 320 €
		'c6320':6222.6,
		'c4310':1778.0,
		'precision3630': 1536.0 }
	guarantee5YearsPrice = {
		'c6220':880.0,
		'r620':240.0,
		'r630':240.0,
		'r640':0.0,
		'r730':240.0,
		'r940':0.0,
		'c6320':880.0,
		'c4310':240.0,
		'precision3630': 0.0 }
	hddUpgradePrice2To = {
		'c6220':320.0,
		'r620':-20.0,
		'r630':0.0,
		'r640':70.0,
		'r730':0.0,
		'r940':70.0,
		'c6320':0.0,
		'c4310':0.0,
		'precision3630': 0.0}
	
	def getColorCodeFromItemLabel(label):
		generation=label[-1]
		(model, proc_id) = re.split('_', label)
		saturation = {
			'sandy bridge':0.0,
			'ivy bridge':0.2,
			'haswell':0.2,
			'broadwell':0.2,
			'skylake':0.4,
			'coffeelake':0.6,
			'cascadelake':1.0
			}[get_proc_architecture(proc_id)]
			# 		if model == 'r620':
			# 			color = 'r'
			# 		elif model == 'r630':
			# 			color = 'g'
			# 		elif model == 'r730':
			# 			color = 'm'
			# 		elif model == 'c6220':
			# 			if generation == '2':
			# 				color = 'b'
			# 			else:
			# 				color = 'y'
		hue = {
			'r620': 0.6,
			'r630': 0.6,
			'r640': 0.6,
			'c4310': 0.6,
			'r730': 0.4,
			'r940': 0.8,
			'c6220': 1.0,
			'c6320': 1.0,
			'precision3630': 0.2
			}[model]
		value = 0.9
		return matplotlib.colors.hsv_to_rgb((hue, saturation, value))

	def get_marker_from_label(label):
		(model, proc_id) = re.split('_', label)
		return get_marker(proc_id)


	itemPrice = numpy.array([])
	itemPowerConsumption = numpy.array([])
	itemSpeed = numpy.array([])
	itemLabel = numpy.array([])
	itemGeneration = numpy.array([])
	for hostTypeId, procId, procOptionPrice in zip(dellPriceTable['host_type_id'], dellPriceTable['proc_id'], dellPriceTable['proc_option_price']):
		#print(hostTypeId)
		#if hostTypeId == 'r630':
		#	continue
		proc_arch = get_proc_architecture(procId)
		if not proc_arch in ['coffeelake', 'skylake','cascadelake']:
			continue
		
		itemGeneration = procId[-1]
		
		itemLabel = numpy.append( itemLabel, hostTypeId + '_' + procId )
		itemPrice = numpy.append( itemPrice, procOptionPrice + get_system_base_price(hostTypeId) + ramUpgradePrice128Gb[hostTypeId] + guarantee5YearsPrice[hostTypeId] + hddUpgradePrice2To[hostTypeId] )
		if hostTypeId == 'c6220' or hostTypeId == 'c6320' :
			numServersPerContainer = 4
		else:
			numServersPerContainer = 1
		for id, clock, numCores, tdp, cpumark in zip(cpuTable['id'], cpuTable['clock'], cpuTable['num_cores'], cpuTable['tdp'], cpuTable['cpumark_1_cpu']):
			if id == procId:
				# print('found '+procId)
				break
		assert id == procId, 'Failed to find %s in cputable' % procId
		#print(tdp)
		if hostTypeId == 'precision3630':
			numProcsPerServer = 1
		elif hostTypeId in ['r940']: # re.match('r9[0-9]0', hostTypeId):
			numProcsPerServer = 4
		else:
			numProcsPerServer = 2
		print(hostTypeId, numProcsPerServer)
		itemPowerConsumption = numpy.append( itemPowerConsumption, (tdp*numProcsPerServer+serverBasePowerConsumption)*numServersPerContainer )
		# print(hostTypeId, procId, itemPowerConsumption[-1])
		itemSpeed = numpy.append( itemSpeed, num_dp_flop_per_cycle(procId)*clock*1.e9*numCores*numProcsPerServer*numServersPerContainer)
		#itemSpeed = numpy.append( itemSpeed, GHzToMHz(clock)*numCores*numProcsPerServer*numServersPerContainer)
		#itemSpeed = numpy.append( itemSpeed, cpumark * numProcsPerServer*numServersPerContainer )

	#pylab.plot(x, y, '+')
	#pylab.xlabel('speed/price ratio [core.MHz/euros]')
	#pylab.ylabel('speed/power consumption ratio [core.MHz/W]')
	#pylab.show() # or savefig(<filename>)

	
	#print("items = ")
	#print(itemLabel)

	markerSize = 50

	if False:
		plt.subplot(1,2,1)
		plt.subplots_adjust(bottom = 0.1)
		markersCycler = itertools.cycle(itertools.product(markerTypes, markerColors))
		x = itemSpeed / itemPrice
		y = itemSpeed / itemPowerConsumption
		for label, x1, y1, power, speed, price, in zip(itemLabel, x, y, itemPowerConsumption, itemSpeed, itemPrice):
			marker = markersCycler.next()
			color = getColorCodeFromItemLabel(label)
			plt.scatter( x1, y1, color = color, s = markerSize, marker = marker[0], label = label)
			#print(x1, y1, color, markerSize, marker[0], label)
		if False:
			plt.scatter( x, y, marker = 'o')
			for label, x1, y1, power, speed, price, in zip(itemLabel, x, y, itemPowerConsumption, itemSpeed, itemPrice):
				#print(label)
				plt.annotate( u'%s (%.1f core.GHz, %.0f W, %.0f €)' % (label,speed/1000.0, power, price), 
					xy = (x1, y1), xytext = (-50, 50),
					textcoords = 'offset points', ha = 'right', va = 'bottom',
					bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 0.5),
					arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'))
		plt.xlabel(u'speed/price ratio [core.MHz/€]')
		plt.ylabel(u'speed/power consumption ratio [core.MHz/W]')
		plt.xlim( xmin = 0.0 )
		plt.ylim( ymin = 0.0 )

	plt.subplot(1,2,1)
	#fig = plt.figure()
	#ax = fig.gca()
	#ax.set_xticks(numpy.arange(0,1,0.1))
	#ax.set_yticks(numpy.arange(0,1.,0.1))

	powerUsedInLifetime = (itemPowerConsumption * containerLifetime * 365 * 24) / powerUsageEfficiency
	itemTotalCost = itemPrice + (powerUsedInLifetime / 1000.0 * kWHPrice )
	markersCycler = itertools.cycle(itertools.product(markerTypes, markerColors))
	item_flops = itemSpeed
	# print item_flops
	item_total_num_ops = item_flops * containerLifetime * 365 * 24 * 3600
	# print(itemPrice)
	x = itemPrice
	y = item_total_num_ops / itemTotalCost
	for i in range(len(itemLabel)):
		print(itemLabel[i], itemPrice[i], y[i])
		print('itemTotalCost', itemTotalCost[i])
		print('flops', item_flops[i])
	# print y
	for label, x1, y1, power, speed, price, in zip(itemLabel, x, y, itemPowerConsumption, itemSpeed, itemPrice):
		if y1 > 0.0001:
			color = getColorCodeFromItemLabel(label)
			# marker = markersCycler.next()
			marker = get_marker_from_label( label )
			#print(x1, y1)
			plt.scatter( x1, y1, facecolors = color, s = markerSize, marker = marker[0], label = label)
			if y1 > 5.7e16:
				plt.annotate( u'%s' % label, 
					xy = (x1, y1), xytext = (x1*4.0, (y1-5.5e16)*7.1),
					textcoords = 'data', ha = 'right', va = 'bottom',
					bbox = dict(boxstyle = 'round,pad=0.5', fc = 'yellow', alpha = 0.5),
					arrowprops = dict(arrowstyle = '->', connectionstyle = 'arc3,rad=0'))

	plt.xlabel(u'purchase price [€]')
	plt.ylabel(u'num total DP operations/total cost [€/^-1]')
	plt.title(u'total cost including electricity')
	plt.xlim( xmin = 0.0 )
	plt.ylim( ymin = 0.0 )
	plt.minorticks_on()
	plt.grid(b=True, which='major', color='b', linestyle='-', linewidth=0.5)
	plt.grid(b=True, which='minor', color='b', linestyle='-', linewidth=0.2)	
	plt.legend(bbox_to_anchor=(1.1, 1.1), ncol=3)
	plt.draw()


	plt.show()

#plotCpuPassmark():
plotSystemEfficiency()