Navigation

← Previous Changeset
Next Changeset →

Changeset 140

Timestamp:

11/17/07 17:17:36 (10 months ago)

Author:

Don Clugston

Message:

* Fixed a nasty codegen bug in X87.
* Speedup for enquote().
* Now uses revised expressions for everything -- more complex examples should now be possible!

Files:

trunk/blade/Blade.d (modified) (9 diffs)
trunk/blade/BladeRank.d (modified) (3 diffs)
trunk/blade/BladeSimplify.d (modified) (2 diffs)
trunk/blade/BladeUtil.d (modified) (1 diff)
trunk/blade/CodegenX86.d (modified) (1 diff)
trunk/blade/SyntaxTree.d (modified) (1 diff)

Legend:

: Unmodified
: Added
: Removed
: Modified
: Copied
: Moved

trunk/blade/Blade.d

r139	r140
56	56	char [] vectorize(char [] expr)
57	57	{
58		return "mixin(makeVectorCode(" ~ syntaxtreeof(expr) ~ "));";
	58	return "pragma(msg, \\n ~ makeVectorCode(" ~ syntaxtreeof(expr) ~ ")~\\n);"
	59	"mixin(makeVectorCode(" ~ syntaxtreeof(expr) ~ "));";
59	60	}
60	61
…	…
86	87	void SSEVECGEN(int SSEVersion, char [] expr, Values...)(int veclength, Values values) {
87	88	const ranklist = TupleRank!(Values);
88		pragma(msg, generateCodeForSSE(SSEVersion, ranklist, expr));
	89	// pragma(msg, generateCodeForSSE(SSEVersion, ranklist, expr));
89	90	mixin(generateCodeForSSE(SSEVersion, ranklist, expr));
90	91	}
…	…
98	99	const char [] expr = rawexpr;
99	100
100		pragma(msg, generateCodeForAsmX87(typelist, ranklist, expr));
	101	// pragma(msg, generateCodeForAsmX87(typelist, ranklist, expr));
101	102	mixin(generateCodeForAsmX87(typelist, ranklist, expr));
102	103	}
…	…
215	216	result ~= ")(";
216	217	int firstVector = findVectorForLength(tree, revised);
217		return result ~ ~~tree.symbolTable[firstVector].value~~ ~ ".length" ~ vals ~ ");";
	218	return result ~ getValueForSymbol(revised.mapping[firstVector], tree, revised) ~ ".length" ~ vals ~ ");";
218	219	}
219	220
…	…
238	239	result ~= ")(";
239	240	int firstVector = findVectorForLength(tree, revised);
240		result ~= tree.symbolTable[firstVector].value ~ ".length";
	241	result ~= getValueForSymbol(revised.mapping[firstVector], tree, revised) ~ ".length";
	242	// result ~= tree.symbolTable[firstVector].value ~ ".length";
241	243	result ~= vals;
242	244
…	…
251	253	char [] result ="";
252	254	int firstVector = findVectorForLength(tree, revised);
253		bool known = arrayLengthIsStatic(tree.symbolTable[firstVector].type);
254		for (int i=0; i<~~tree.symbolTable~~.length;++i) {
255		if (~~tree.symbolTable[i].rank=='1')~~{
	255	// bool known = arrayLengthIsStatic(tree.symbolTable[firstVector].type);
	256	for (int i=0; i<revised.mapping.length;++i) {
	257	if (revised.rank[i]=='1') {
256	258	if (firstVector != i) {
257		if (known && arrayLengthIsStatic(tree.symbolTable[i].type)) {
258		// both lengths are known at compile time - make it a
259		// compile-time static assert
260		result ~= "static ";
261		}
262		result ~= "assert(" ~ tree.symbolTable[i].value
263		~ ".length==" ~ tree.symbolTable[firstVector].value
	259	// if (known && arrayLengthIsStatic(tree.symbolTable[i].type)) {
	260	// // both lengths are known at compile time - make it a
	261	// // compile-time static assert
	262	// result ~= "static ";
	263	// }
	264	result ~= "assert("
	265	~ getValueForSymbol(revised.mapping[i], tree, revised)
	266	~ ".length==" ~ getValueForSymbol(revised.mapping[firstVector], tree, revised)
264	267	~ ".length, `Vector length mismatch`);"\n;
265	268	}
…	…
273	276	char [] result ="";
274	277	for (int i=0; i<revised.mapping.length;++i) {
275		if (~~tree.symbolTable[i].rank~~=='1'){
276		result ~= "assert( (cast(size_t)(" ~ ~~tree.symbolTable[i].value~~
277		~ ".ptr)& 0x1F) == 0, `SSE Vector misalignment: " ~ ~~tree.symbolTable[i].value~~ ~ "`);"\n;
	278	if (revised.rank[i]=='1'){
	279	result ~= "assert( (cast(size_t)(" ~ getValueForSymbol(revised.mapping[i], tree, revised)
	280	~ ".ptr)& 0x1F) == 0, `SSE Vector misalignment: " ~ getValueForSymbol(revised.mapping[i], tree, revised) ~ "`);"\n;
278	281	}
279	282	}
…	…
294	297	{
295	298	int dynamic = 0; // last dynamic vector
296		for (int i=0; i<tree.symbolTable.length; ++i) {
297		if (tree.symbolTable[i].rank=='1') {
298		dynamic = i;
299		if (arrayLengthIsStatic(tree.symbolTable[i].type)) return i;
	299	for (int i = 0; i < revised.mapping.length; ++i) {
	300	if (revised.rank[i]!='1') continue;
	301	int x = revised.mapping[i]-'A';
	302	dynamic = i;
	303	if (x < tree.symbolTable.length) {
	304	if (arrayLengthIsStatic(tree.symbolTable[x].type)) return i;
300	305	}
301	306	}
302	307	return dynamic;
	308
303	309	}
304	310
…	…
323	329	int lenvec = findVectorForLength(tree, revised);
324	330	char [] result = "for (int blade_index=0; blade_index<"
325		~ tree.symbolTable[lenvec].value ~ ".length; ++blade_index) {";
	331	~ getValueForSymbol(revised.mapping[lenvec], tree, revised) ~
	332	//~ tree.symbolTable[lenvec].value ~
	333	".length; ++blade_index) {";
326	334	foreach (c; revised.expression) {
327	335	if (c>='A' && c<'Z') {

trunk/blade/BladeRank.d

r139	r140
1	1	// Written in the D programming language 1.0
2	2	/**
3		* BLADE 0.3Alpha -- Basic Linear Algebra D Expressions
	3	* Part of BLADE : Basic Linear Algebra D Expressions
	4	*
4	5	*/
5	6
…	…
139	140
140	141	/** Determine the (tensor) rank of a sub-expression
	142	* The sub-expression must be a single character, or an expression in
	143	* parentheses.
141	144	*/
142	145	int subexprRank(char [] expr, char [] rank)
…	…
291	294	}
292	295
293
294		~~// Rank functions also using placeholder expressions~~
295
296	296	/** Returns the resultant element type of the tensor expression expr.
297	297	*

trunk/blade/BladeSimplify.d

r139	r140
113	113	char [] m = scalar;
114	114	if (mulexpr.length>0) m = "(" ~ mulexpr ~ "*" ~ scalar ~ ")";
	115	// BUG: It's also worth scalar folding A(BU[]-V[]) into (AB)U[]+(-A)*V[],
115	116	if (tensor.length > 1 && hasScalarMultiply(tensor[1..$-1], rank)) {
116	117	// opportunity for scalar folding
…	…
199	200	}
200	201	return r;
	202	}
	203
	204
	205	// return true if the given symbol has a non-zero stride.
	206	// s must end with an index or slicing expression.
	207	bool isStrided(char [] s)
	208	{
	209	assert(s[$-1]==']', "BLADE BUG");
	210	if (s[$-2..$]=="[]") return false;
	211	int numbrack=0;
	212	bool retval = true;
	213	for (int i = s.length-2; i>1; --i) {
	214	if (s[i]==']') numbrack--;
	215	if (s[i]=='[') {
	216	if (numbrack==0) return retval;
	217	numbrack++;
	218	}
	219	if (numbrack==0 && s[i]=='.' && s[i-1]=='.') {
	220	// it's a slice
	221	retval = false;
	222	}
	223	}
	224	}
	225
	226	unittest {
	227	assert(!isStrided("A[3..5][]"));
	228	assert(isStrided("A[2..7][3]"));
	229	assert(!isStrided("A[7][B[2]..6]"));
201	230	}
202	231

trunk/blade/BladeUtil.d

r139	r140
30	30	}
31	31
32		/** Escape any quotes and backslashes inside the given string
	32	/** Escape any quotes and backslashes inside the given string,
	33	* prefixing them with the given escape sequence. Use `\` to escape
	34	* once, `\\\` to escape twice.
33	35	*/
34		char [] enquote(char [] instr)
	36	char [] enquote(char [] instr, char [] escape=`\`)
35	37	{
	38	// This function is critical for compilation time.
	39	// Need to minimise the number of allocations.
36	40	// It's worth using copy-on-write even for CTFE.
	41
37	42	for(int i=0; i<instr.length; ++i) {
38	43	if (instr[i]=='"' \|\| instr[i]=='\\') {
39		char [] str=instr[0..i];
40		foreach(char c; instr[i..$]) {
41		if (c=='"' \|\| c=='\\') str ~= `\`;
42		str ~= c;
	44	char [] str=instr[0..i] ~ escape;
	45	int m = i;
	46	foreach(int k, char c; instr[i+1..$]) {
	47	if (c=='"' \|\| c=='\\') {
	48	str ~= instr[m..i+1+k] ~ escape;
	49	m = i+k+1;
	50	}
43	51	}
44		return str;
	52	return str ~ instr[m..$];
45	53	}
46		}
47		return instr;
	54	}
	55	return instr;
48	56	}
49	57

trunk/blade/CodegenX86.d

r136	r140
449	449	// load a vector onto the FPU stack, to begin a new subexpression.
450	450	int u = operations[done]-'A';
451		next = " fld " ~ indexedVector(typelist, ranklist, operations[done] ) ~ "; //" ~ operations[done] ~\n;
	451	if (ranklist[operations[done]-'A']==1) {
	452	next = " fld " ~ indexedVector(typelist, ranklist, operations[done] ) ~ "; //" ~ operations[done] ~\n;
	453	} else { // load constant. Will never be a real
	454	next = " fld " ~ operandSize(typelist[operations[done]-'A']) ~ "values[" ~ itoa(operations[done]-'A') ~"]; // * " ~ operations[done..done+1] ~ "\n";
	455	}
452	456	mainbody ~= next; firstbody ~= next;
453	457	++done;

trunk/blade/SyntaxTree.d

r138	r140
343	343	return `(` ~ sym ~ `).stringof~""`;
344	344	}
345		return `mixin(is(typeof(` ~ sym ~ `)==function) \|\| !is(typeof(` ~ sym ~ `))?"\"` ~ enquote(~~enquote(sym)~~) ~ `\"":"` ~ enquote(sym ~ ".stringof") ~ `")`;
	345	return `mixin(is(typeof(` ~ sym ~ `)==function) \|\| !is(typeof(` ~ sym ~ `))?"\"` ~ enquote(sym, `\\\`) ~ `\"":"` ~ enquote(sym ~ ".stringof") ~ `")`;
346	346	}
347	347

mathextra