Here is a little Python script, that I wrote to compute yields for the PS3’s Cell chip on a 300mm wafer with different defect rates, depending on the number of SPEs required to be intact…

#!/usr/bin/env python

from Numeric import *
import random

num_wavers = 100 # average over this many wavers

wafer_size = (300.0, 300.0) # mm (diameter, but we'll assume a square of that size)
die_size = (12.28, 18.0) # mm
spe_size = (5.81, 2.5) # mm

defect_rate = 0.4 # per cm^2

spe_columns = 2
spe_rows = 4
num_spes = spe_columns * spe_rows

dies_per_row = int(wafer_size[0] / die_size[0])
dies_per_column = int(wafer_size[1] / die_size[1])

dead = 0
working_spes = zeros((num_spes + 1,), Int)

for waver in range(num_wavers):
  defect_table = zeros((dies_per_column, dies_per_row, 1 + num_spes), Int8)

  num_defects = int((wafer_size[0] * wafer_size[1]) / 100.0 * defect_rate)
  for d in range(num_defects):
    x = random.uniform(0.0, wafer_size[0])
    y = random.uniform(0.0, wafer_size[1])
    column = int(x / die_size[0])
    row = int(y / die_size[1])
    if (column < dies_per_column) and (row < dies_per_row): # this could be false on the last die in each row / column
      x -= column * die_size[0] # position within the die
      y -= row * die_size[1]
      if (x < spe_columns * spe_size[0]) and (y < spe_rows * spe_size[1]):
        # we've hit an SPE
        spe_index = int(y / spe_size[1]) * spe_columns + int(x / spe_size[0])
        defect_table[column][row][1 + spe_index] = True
      else:
        # we've hit another part of the die and the whole thing is broken
        defect_table[column][row][0] = True

  # now go through the table and sum the results
  for y in range(dies_per_row):
    for x in range(dies_per_column):
      if (defect_table[x][y][0]):
        dead += 1
      else:
        working_spes[num_spes - sum(defect_table[x][y][1:])] += 1

print "Wafer Size (mm)", wafer_size
print "Die Size (mm)", die_size
print "SPE Size (mm)", spe_size
print "Defect Rate (per cm^2)", defect_rate
print "Total Dies", dies_per_row * dies_per_column
print "Average Dead / Wafer", dead / float(num_wavers)
print "Working SPEs", working_spes / num_wavers
print "Yield (7 SPEs)", (working_spes[7] + working_spes[8]) / float(num_wavers * dies_per_row * dies_per_column)
print "Yield (8 SPEs)", (working_spes[8]) / float(num_wavers * dies_per_row * dies_per_column)