795219_it-IT

liliconcom

Ottimizzare il calcolo

CIAO,

Ho un codice jsl per calcolare la distanza radiale dal centro del wafer. La tabella dati XYCoord ha colonne X, Y e wafer id.

Calcola la distanza e aggiunge una colonna di distanza a 1 mm dal centro della tabella

Attualmente, con 656k righe, ci vogliono > 3-4 minuti per completare il processo, il che è decisamente troppo.

C'è un modo per ottimizzarlo e renderlo più veloce?

Automazione e scriptingRe: Ottimizzare il calcolo

Ho provato a eseguire il tuo script in base ai dati che hai fornito, ma non è riuscito. Il primo elemento che ho provato a correggere è stato un "=" vagante su varie righe nello script.

Le linee 23, 25, 106, 139 e 152 avevano tutte un singolo "=" su di esse

Successivamente i messaggi di errore si sono rivolti a quelle che apparentemente erano colonne che venivano ripulite da esecuzioni precedenti, ma nella tabella fornita non sono presenti, quindi lo script fallisce.

RadiusDieCenter, centratura x, centratura y, raggio arrotondato 1 mm, raggio arrotondato 0,51 mm

Ho aggiunto Try() attorno alle linee incriminate

La colonna X Coord sulla riga 21 è referenziata ma non esiste nella tabella dati

L'ho cambiato in U1_x supponendo che sia la colonna di coordinate x per l'esecuzione

Il codice è stato quindi eseguito senza errori in 2 minuti e 12 secondi, tuttavia non so se i risultati sono quelli corretti. Le colonne Xcentering e Ycentering sono tutte zero. È questo che ci si aspetta?

Re: Ottimizzare il calcolo

Ciao Jim,

Sì, è corretto. Puoi verificare i risultati tracciando il grafico X e Y ed evidenziando i valori di 1 mm di colonna. Mi chiedevo se questo può essere ulteriormente ottimizzato. Ho corretto gli errori nel file jsl allegato sopra

Re: Ottimizzare il calcolo

Ciao @Jackie_ ,

Lo script ha ricalcolato diversi valori Col in ogni ciclo. Prova questo:

fine - inizio = 6.15000000002328;

Names Default To Here( 1 );
start = Tick Seconds();
dt = Current Data Table();
dt << Clear Column Selection;
Try( dt << delete columns( RadiusDieCenter ) );
Try(
	dt << delete columns( RadiusDieEdge );


	dt << delete columns( Xcentering );
	dt << delete columns( Ycentering );
	dt << delete columns( Radius Rounded 1mm );
	dt << delete columns( Radius Rounded 0.51mm );
	dt << delete columns( Radius Rounded 1mm );
);

z5Identifier = 1;
Xaxis = "U1_x";
Yaxis = "U1_y";
DieXSize = 1.160; //in mm
DieYSize = 0.810;//in mm

WaferColumns = N Items( Associative Array( As Column( Xaxis ) ) << Get Keys );
columnsRad = ((WaferColumns * DieXSize) / 2);
										
MaxRadiusEntry = 147;

	
				
dt << Set Table Variable( "DieXSize", DieXSize );
dt << Set Table Variable( "DieYSize", DieYSize );
dt << Set Table Variable( "MaxRadius", MaxRadiusEntry );


dt << begin data update;
				

xcoordmax = Col Maximum( As Column( Xaxis ) );
xcoordmin = Col Minimum( As Column( Xaxis ) );
ycoordmax = Col Maximum( As Column( Yaxis ) );
ycoordmin = Col Minimum( As Column( Yaxis ) );

					
New Column( "RadiusDieCenter",
	Formula( Sqrt( (Abs( (As Column( Xaxis ) - CenterXCoord) * DieXSize )) ^ 2 + Abs( ((As Column( Yaxis ) - CenterYCoord) * DieYSize) ) ^ 2 ) )
);
							
 

					  
New Column( "RadiusDieEdge",
	Formula(
		Sqrt(
			(Abs( (As Column( Xaxis ) - CenterXCoord) * DieXSize ) + Abs( DieXSize / 2 )) ^ 2 + (Abs(
				(As Column( Yaxis ) - CenterYCoord) * DieYSize
			) + Abs( DieYSize / 2 )) ^ 2
		)
	)
);
							


xcoordrange = xcoordmax - xcoordmin;
ycoordrange = ycoordmax - ycoordmin;
dt << Set Table Variable( "CenterXCoord", xcoordmin + xcoordrange / 4 );
dt << Set Table Variable( "CenterYCoord", ycoordmin + ycoordrange / 4 );
dt << Run Formulas;
xiter = Ceiling( Log( xcoordrange * 1600, 1.8 ) );
yiter = Ceiling( Log( ycoordrange * 1600, 1.8 ) );
maxiter = Max( xiter, yiter );



New Column( "Xcentering",
	Numeric,
	Formula(
		If( As Column( Xaxis ) > :CenterXCoord & :RadiusDieEdge > :MaxRadius,
			1,
			If( As Column( Xaxis ) < :CenterXCoord & :RadiusDieEdge > :MaxRadius,
				-1,
				0
			)
		)
	)
);

New Column( "Ycentering",
	Numeric,
	Formula(
		If( As Column( Yaxis ) > :CenterYCoord & :RadiusDieEdge > :MaxRadius,
			1,
			If( As Column( Yaxis ) < :CenterYCoord & :RadiusDieEdge > :MaxRadius,
				-1,
				0
			)
		)
	)
);


dt << end data update;

sum_x_centering = Col Sum( :Xcentering );
min_x_centering = Col Min( :Xcentering );
max_x_centering = Col Max( :Xcentering );
sum_y_centering = Col Sum( :Ycentering );
min_y_centering = Col Min( :Ycentering );
max_y_centering = Col Max( :Ycentering );

For( i = 1, i <= maxiter, i++, 



	centerx = Num( dt << Get Table Variable( "CenterXCoord" ) );
	centery = Num( dt << Get Table Variable( "CenterYCoord" ) );

	xcoordrange = xcoordrange / 1.8;
	ycoordrange = ycoordrange / 1.8;
	dt << Run Formulas;
	If( sum_x_centering > 0,
		dt << Set Table Variable( "CenterXCoord", centerx + xcoordrange );
		centerx = centerx + xcoordrange;
	,
		If( sum_x_centering < 0, 

			dt << Set Table Variable( "CenterXCoord", centerx - xcoordrange );
			centerx = centerx + xcoordrange;
					
		)
	);

	If( sum_y_centering > 0,
		dt << Set Table Variable( "CenterYCoord", centery + ycoordrange );
		centery = centery + ycoordrange;
	,
		If( sum_y_centering < 0, 

			dt << Set Table Variable( "CenterYCoord", centery - ycoordrange );
			centery = centery + ycoordrange;
					
		)
	);
				
	If( max_x_centering < 1 & min_x_centering > -1 & max_y_centering < 1 & min_y_centering > -1, 
					
		OldRadius = dt << Get Table Variable( "MaxRadius" );
		NewRadius = Num( OldRadius ) - 0.01;
		dt << Set Table Variable( "MaxRadius", Char( NewRadius ) );
		xcoordrange = xcoordmax - xcoordmin;
		ycoordrange = ycoordmax - ycoordmin;
		dt << Run Formulas;
		i = 1;
	);

	dt << Run Formulas;

);

New Column( "Radius Rounded 1mm", Numeric, "Continuous", Format( "Best", 12 ), Formula( Ceiling( :RadiusDieEdge ) ) );


end = Tick Seconds();

Show( end - start );

Re: Ottimizzare il calcolo

Ciò che secondo me potrebbe essere utile per velocizzare l'elaborazione è ricodificare lo script ed eliminare l'utilizzo degli script di tabella come archivio intermedio.

Ho eseguito un piccolo test per verificare l'efficienza dell'utilizzo di una variabile di tabella rispetto a una variabile di memoria e, nel mio test, il metodo della variabile di tabella ha impiegato 26 secondi per l'elaborazione, mentre il metodo della variabile di memoria ha impiegato 0,5 secondi.

Prendi in considerazione l'utilizzo di una variabile di memoria globale o la creazione di una variabile name space per salvare i tuoi calcoli provvisori. Se vuoi finire con le variabili della tabella che hanno i valori finali, devi solo impostarle una volta alla fine del tuo script.

Re: Ottimizzare il calcolo

Fantastico. Ti dispiacerebbe condividere Jim?

Re: Ottimizzare il calcolo

I risultati sono errati @robot

Dovrebbe essere con il mio copione

Re: Ottimizzare il calcolo

Ecco i 2 script di test che ho utilizzato

names default to here(1);
dt = new table("example");
dt << new table variable("test",42);
start = tick seconds();
dt=current data table();
for(i=1,i<=1000000,i++,
	x=num(dt<<GET table="" variable=""></GET>

<CODE class=" language-jsl">names default to here(1);
If(!isnamespace(t), t = new namespace("temp"));
start = tick seconds();
dt=current data table();
t:x=1;
for(i=1,i<=1000000,i++,
y = t:x;
y=y+1;
t:x=y;
);
end = tick seconds();

show(end -start);

Re: Ottimizzare il calcolo

Dando una rapida occhiata allo script, molto probabilmente ci sono molte ottimizzazioni diverse che si possono fare, ma sono un po' confuso su cosa stai calcolando.

• Come si determina il centro del wafer a partire da questi dati?
• Distanza dal centro del wafer a quale raggio?
• L'intero dado deve rientrare nei raggi o solo nel centro?

Re: Ottimizzare il calcolo

Sono state fatte molte ipotesi

/*""" Optimize the computation
author: jthi
date: 2024-09-05
url: https://community.jmp.com/t5/Discussions/Optimize-the-computation/m-p/795219
keywords/tags: [semiconductor,wafer,distance,matrix,die]

Description: Calculate distance from center of wafer (coordinates) to corner of die
"""*/

Names Default To Here(1);

dt_temp = Open("$DOWNLOADS/XYCoord.jmp");

die_width = 1.160;
die_height = 0.810;


dt = dt_temp << Summary(
	Group(:U1_x, :U1_y),
	Freq("None"),
	Weight("None"),
	Link to original data table(0),
	output table name("Coords")
);
dt << Delete Scripts(dt << Get Table Script Names);

// Use Update to join the distances back using U1_x and U1_y as linking ids
Close(dt_temp, no save); // Close as not needed for this demo


m_x = Column(dt, "U1_x") << get values;
m_y = Column(dt, "U1_y") << get values;


// Origo to 0, 0 and coordinates to "real" measures
// This most likely will require some adjustments but you know your data so you should be able to modify this as needed
xcoords = (m_x - Max(m_x) / 2) * die_width + die_width / 2;
ycoords = (m_y - Max(m_y) / 2) * die_height + die_height / 2;


// Distance from center to each of the corners of rectangle
// assumes that the "coordinate" is at the center of die
top_left = xcoords - die_width / 2 || ycoords + die_height / 2;
bottom_left = xcoords - die_width / 2 || ycoords - die_height / 2;
top_right = xcoords + die_width / 2 || ycoords + die_height / 2;
bottom_right = xcoords + die_width / 2 || ycoords - die_height / 2;

d_tl = Sqrt(Distance(top_left, [0 0]));
d_bl = Sqrt(Distance(bottom_left, [0 0]));
d_tr = Sqrt(Distance(top_right, [0 0]));
d_br = Sqrt(Distance(bottom_right, [0 0]));

// Assume that furthest part of die is the determining factor for distance
die_distance_to_center = Round(V Max((d_tl || d_bl || d_tr || d_br)`));

dt << New Column("D", Numeric, Ordinal, Values(die_distance_to_center));



nw = New Window("Demo",
	H List Box(
		dt << Data Filter(
			Add Filter(columns(:D), Display(:D, N Items(15), Find(Set Text(""))))
		),
		gb = dt << Graph Builder(
			Size(528, 463),
			Show Control Panel(0),
			Lock Scales(1),
			Variables(X(:U1_x), Y(:U1_y)),
			Elements(Points(X, Y, Legend(4))),
			SendToReport(
				Dispatch({}, "U1_x", ScaleBox,
					{Format("Fixed Dec", 12, 0), Min(-2.87573722663528), Max(261.04),
					Inc(50), Minor Ticks(1)}
				),
				Dispatch({}, "U1_y", ScaleBox,
					{Format("Fixed Dec", 12, 0), Min(-3.300675), Max(380), Inc(100),
					Minor Ticks(4)}
				)
			)
		)
	)
);

Write();

Re: Ottimizzare il calcolo

@jthi

1. Il centro del wafer viene determinato calcolando gli intervalli delle coordinate X e Y (vale a dire, i valori massimi meno quelli minimi). Le stime iniziali per il centro vengono calcolate come:
- CenterXCoord = xcoordmin + xcoordrange / 4
- CenterYCoord = ycoordmin + ycoordrange / 4

Il codice quindi regola iterativamente queste coordinate dividendo l'intervallo di coordinate per 1,8 in ogni iterazione finché non vengono soddisfatte le condizioni di centraggio X e Y. Il centro finale viene trovato quando le formule di centraggio per entrambi gli assi

2. Il raggio viene calcolato dal centro del wafer all'ingresso della matrice "RadiusDieCenter" o al bordo della matrice "RadiusDieEdge"

3. Solo il centro del dado deve rientrare nei raggi calcolati. I calcoli del raggio si concentrano sulla distanza dal centro del wafer al centro di ciascun dado.