795219_fr-FR

liliconcom

Optimiser le calcul

Salut,

J'ai un code jsl pour calculer la distance radiale à partir du centre de la plaquette. La table de données XYCoord contient les colonnes X, Y et l'ID de la plaquette.

Il calcule la distance et ajoute une colonne de distance à 1 mm du centre du tableau

Actuellement, avec 656 000 lignes, le processus prend plus de 3 à 4 minutes pour se terminer, ce qui est beaucoup trop long.

Existe-t-il un moyen de l’optimiser et de le rendre plus rapide ?

Automatisation et scriptsRe: Optimiser le calcul

J'ai essayé d'exécuter votre script sur les données que vous avez fournies, et cela a échoué. Le premier élément que j'ai essayé de corriger était un « = » errant sur plusieurs lignes du script.

Les lignes 23, 25, 106, 139 et 152 avaient toutes un simple "="

Ensuite, les messages d'erreur se sont tournés vers ce qui semble être des colonnes qui sont apparemment nettoyées à partir d'exécutions précédentes, mais dans la table que vous avez fournie, elles ne sont pas là, donc le script échoue.

RadiusDieCenter, xcentering, ycentering, rayon arrondi 1 mm, rayon arrondi 0,51 mm

J'ai ajouté Try() autour des lignes incriminées

La colonne X Coord sur la ligne 21 est référencée mais n'existe pas dans la table de données

Je l'ai changé en U1_x en supposant que c'est la colonne de coordonnées x pour l'exécution

Le code s'est ensuite exécuté sans erreur en 2 minutes et 12 secondes, mais je ne sais pas si les résultats sont corrects. Les colonnes Xcentering et Ycentering sont toutes des zéros. Est-ce ce qui est attendu ?

Re: Optimiser le calcul

Salut Jim,

Oui, c'est correct. Vous pouvez vérifier les résultats en traçant les graphiques X et Y et en mettant en surbrillance les valeurs de colonne de 1 mm. Je me demande si cela peut être optimisé davantage. J'ai corrigé les erreurs dans le fichier jsl ci-dessus.

Re: Optimiser le calcul

Salut @Jackie_ ,

Le script a recalculé plusieurs valeurs Col à chaque boucle. Veuillez essayer ceci :

fin - début = 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: Optimiser le calcul

Ce que je vois comme ce qui pourrait être utilisé pour accélérer votre traitement est de recoder votre script et de supprimer l'utilisation des scripts de table comme stockage intermédiaire.

J'ai effectué un petit test pour vérifier l'efficacité de l'utilisation d'une variable de table par rapport à l'utilisation d'une variable de mémoire, et dans mon test, la méthode de la variable de table a utilisé 26 secondes pour traiter, et la méthode de la variable de mémoire a pris 0,5 seconde.

Envisagez d'utiliser une variable de mémoire globale ou de créer une variable d'espace de noms pour enregistrer vos calculs intermédiaires. Si vous souhaitez que les variables de table aient les valeurs finales, il vous suffit de les définir une fois à la fin de votre script.

Re: Optimiser le calcul

C'est super. Ça te dérange de partager Jim ?

Re: Optimiser le calcul

Les résultats sont incorrects @robot

Devrait être avec mon script

Re: Optimiser le calcul

Voici les 2 scripts de test que j'ai utilisés

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: Optimiser le calcul

En parcourant rapidement le script, il y a très probablement de nombreuses optimisations différentes qui peuvent être effectuées, mais je suis un peu confus quant à ce que vous calculez.

• Comment le centre de la plaquette est-il déterminé à partir de ces données ?
• Distance du centre de la plaquette à quel rayon ?
• Est-ce que l'ensemble du dé doit appartenir aux rayons ou juste au centre ?

Re: Optimiser le calcul

Beaucoup d'hypothèses ont été émises

/*""" 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: Optimiser le calcul

@jthi

1. Le centre de la plaquette est déterminé en calculant les plages des coordonnées X et Y (c'est-à-dire le maximum moins les valeurs minimales). Les estimations initiales pour le centre sont calculées comme suit :
- CentreXCoord = xcoordmin + xcoordrange / 4
- CentreYCoord = ycoordmin + ycoordrange / 4

Le code ajuste ensuite ces coordonnées de manière itérative en divisant la plage de coordonnées par 1,8 à chaque itération jusqu'à ce que les conditions de centrage X et Y soient remplies. Le centre final est trouvé lorsque les formules de centrage pour les deux axes

2. Le rayon est calculé à partir du centre de la plaquette jusqu'à l'entrée de la matrice « RadiusDieCenter » ou jusqu'au bord de la matrice « RadiusDieEdge »

3. Seul le centre de la puce doit être compris dans les rayons calculés. Les calculs de rayon se concentrent sur la distance entre le centre de la plaquette et le centre de chaque puce.