Previous

199869 Revisions

Next

r30755 Sunday 1st June, 2014 at 12:07:48 UTC by Couriersud
Document & save work. Pretty convoluted code now. I'd really miss the good old Cray C90. Clean Fortran code, seamless vectorization and parallelization. That's now 20 years ago and I am fighting with cryptic vectorization compiler messages today.

[src/emu/netlist]	plists.h
[src/emu/netlist/analog]	nld_solver.c nld_solver.h

trunk/src/emu/netlist/analog/nld_solver.c

r30754	r30755
14	14	#endif
15	15
16	16	#define USE_PIVOT_SEARCH (0)
	17	#define VECTALT 1
17	18
18	19	#define SOLVER_VERBOSE_OUT(x) do {} while (0)
19	20	//#define SOLVER_VERBOSE_OUT(x) printf x
r30754	r30755
22	23	* the vectorizations this enables pretty expensive
23	24	*/
24	25
25		//#pragma GCC optimize "-ffast-math"
	26	#if 0
	27	#pragma GCC optimize "-ffast-math"
	28	#pragma GCC optimize "-fvariable-expansion-in-unroller"
	29	#pragma GCC optimize "-funswitch-loops"
	30	#endif
26	31
	32
	33	static vector_t *create_vector(const int size)
	34	{
	35	switch (size)
	36	{
	37	case 1:
	38	return new vector_imp_t<1>();
	39	case 2:
	40	return new vector_imp_t<2>();
	41	case 3:
	42	return new vector_imp_t<3>();
	43	case 4:
	44	return new vector_imp_t<4>();
	45	case 5:
	46	return new vector_imp_t<5>();
	47	case 6:
	48	return new vector_imp_t<6>();
	49	case 7:
	50	return new vector_imp_t<7>();
	51	case 8:
	52	return new vector_imp_t<8>();
	53	default:
	54	return new vector_imp_t<0>(size);
	55	}
	56	}
	57
	58	ATTR_COLD void terms_t::add(netlist_terminal_t *term, int net_other)
	59	{
	60	m_term.add(term);
	61	m_net_other.add(net_other);
	62	m_gt.add(0.0);
	63	m_go.add(0.0);
	64	m_Idr.add(0.0);
	65	}
	66
	67	ATTR_COLD void terms_t::set_pointers()
	68	{
	69	for (int i = 0; i < count(); i++)
	70	{
	71	m_term[i]->m_gt1 = &m_gt[i];
	72	m_term[i]->m_go1 = &m_go[i];
	73	m_term[i]->m_Idr1 = &m_Idr[i];
	74	}
	75
	76	m_ops = create_vector(m_gt.count());
	77	}
	78
27	79	// ----------------------------------------------------------------------------------------
28	80	// netlist_matrix_solver
29	81	// ----------------------------------------------------------------------------------------
r30754	r30755
68	120	switch (p->netdev().family())
69	121	{
70	122	case netlist_device_t::CAPACITOR:
71		if (!m_steps.contains(&p->netdev()))
72		m_steps.add(&p->netdev());
	123	if (!m_step_devices.contains(&p->netdev()))
	124	m_step_devices.add(&p->netdev());
73	125	break;
74	126	case netlist_device_t::BJT_EB:
75	127	case netlist_device_t::DIODE:
76	128	//case netlist_device_t::VCVS:
77	129	case netlist_device_t::BJT_SWITCH:
78	130	NL_VERBOSE_OUT(("found BJT/Diode\n"));
79		if (!m_dynamic.contains(&p->netdev()))
80		m_dynamic.add(&p->netdev());
	131	if (!m_dynamic_devices.contains(&p->netdev()))
	132	m_dynamic_devices.add(&p->netdev());
81	133	break;
82	134	default:
83	135	break;
r30754	r30755
142	194	#endif
143	195	double DD_n = (n->m_cur_Analog - n->m_last_Analog);
144	196
145		if (fabs(DD_n) < 2.0 * m_params.m_accuracy)
146		DD_n = 0.0;
147		else
148		DD_n = copysign(fabs(DD_n) - 2.0 * m_params.m_accuracy, DD_n) / hn;
149
150		double h_n_m_1 = n->m_h_n_m_1;
151		// limit last timestep in equation.
152		//if (h_n_m_1 > 3 * hn)
153		//    h_n_m_1 = 3 * hn;
154
155		double DD2 = (DD_n - n->m_DD_n_m_1) / (hn + h_n_m_1);
	197	double DD2 = (DD_n / hn - n->m_DD_n_m_1 / n->m_h_n_m_1) / (hn + n->m_h_n_m_1);
156	198	double new_net_timestep;
157	199
	200	n->m_h_n_m_1 = hn;
158	201	n->m_DD_n_m_1 = DD_n;
159		n->m_h_n_m_1 = hn;
160	202	if (fabs(DD2) > 1e-50) // avoid div-by-zero
161	203	new_net_timestep = sqrt(m_params.m_lte / fabs(0.5*DD2));
162	204	else
163		{
164	205	new_net_timestep = m_params.m_max_timestep;
165	206
166		//if (hn > 0.0 && new_net_timestep > 100.0 * hn)
167		//    new_net_timestep = 100.0 * hn;
168		}
169		//if (N()==2)
170		//    printf("%s: k %d ts %e DD2 %e\n", name().cstr(), k, new_net_timestep, DD2);
171
172	207	if (new_net_timestep < new_solver_timestep)
173	208	new_solver_timestep = new_net_timestep;
174	209	}
r30754	r30755
205	240	ATTR_HOT void netlist_matrix_solver_t::update_dynamic()
206	241	{
207	242	/* update all non-linear devices  */
208		for (netlist_core_device_t * const *p = m_dynamic.first(); p != NULL; p = m_dynamic.next(p))
	243	for (netlist_core_device_t * const *p = m_dynamic_devices.first(); p != NULL; p = m_dynamic_devices.next(p))
209	244	switch ((*p)->family())
210	245	{
211	246	case netlist_device_t::DIODE:
r30754	r30755
248	283	ATTR_HOT void netlist_matrix_solver_t::step(const netlist_time delta)
249	284	{
250	285	const double dd = delta.as_double();
251		for (int k=0; k < m_steps.count(); k++)
252		m_steps[k]->step_time(dd);
	286	for (int k=0; k < m_step_devices.count(); k++)
	287	m_step_devices[k]->step_time(dd);
253	288	}
254	289
255	290	ATTR_HOT double netlist_matrix_solver_t::solve()
r30754	r30755
265	300	NL_VERBOSE_OUT(("Step!\n"));
266	301	/* update all terminals for new time step */
267	302	m_last_step = now;
268		//printf("usecs: %f\n", delta.as_double()*1000000.0);
269	303	step(delta);
270	304
271	305	if (is_dynamic())
r30754	r30755
297	331	return next_time_step;
298	332	}
299	333
	334	__attribute__ ((noinline)) static double tx(double * ATTR_ALIGN t  , const int &N)
	335	{
	336	double tmp=0.0;
	337	for (int k = 0; k<N; k++)
	338	tmp += t[k] ;
	339	return tmp;
	340	}
	341
	342	void ttt()
	343	{
	344	//typedef int  tt ;
	345	static double *t = (double *) malloc(128*8);
	346	for (int k = 0; k<128; k++)
	347	t[k] = k;
	348	double tmp;
	349	tmp = tx(t, 16);
	350	printf("t[0] %p %f\n", &t[0], t[0]);
	351	printf("t[1] %p %f\n", &t[1], t[1]);
	352	printf("%f\n", tmp);
	353	free(t);
	354
	355	}
	356
300	357	template <int m_N, int _storage_N>
301	358	void netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::log_stats()
302	359	{
303		#if 0
	360	#if 1
304	361	printf("==============================================\n");
305	362	printf("Solver %s\n", this->name().cstr());
306	363	printf("       ==> %d nets\n", this->N()); //, (*(*groups[i].first())->m_core_terms.first())->name().cstr());
r30754	r30755
312	369	this->m_gs_fail,
313	370	100.0 * (double) this->m_gs_fail / (double) this->m_calculations,
314	371	(double) this->m_gs_total / (double) this->m_calculations);
	372	ttt();
	373
315	374	#endif
316	375	}
317	376
r30754	r30755
387	446	double akk  = 0.0;
388	447	{
389	448	const int terms_count = m_terms[k].count();
390		//const netlist_terminal_t * const *terms = m_terms[k].terms();
391		const int *net_other = m_terms[k].net_other();
392	449	const double *gt = m_terms[k].gt();
393		const double *go = m_terms[k].go();
394	450	const double *Idr = m_terms[k].Idr();
	451	#if VECTALT
395	452
396	453	for (int i = 0; i < terms_count; i++)
397	454	{
r30754	r30755
399	456
400	457	rhsk = rhsk + Idr[i];
401	458	akk = akk + gt[i];
402		m_A[k][net_other[i]] += -go[i];
	459	//m_A[k][net_other[i]] += -go[i];
403	460	}
	461	#else
	462	m_terms[k].ops()->sum2(Idr, gt, rhsk, akk);
	463	//                    rhsk += sum(m_terms[k].Idr(), terms_count);
	464	//            akk += sum(m_terms[k].gt(), terms_count);
	465	#endif
404	466	}
405	467	{
406	468	const int rails_count = m_rails[k].count();
407	469	const netlist_terminal_t * const *rails = m_rails[k].terms();
408	470	const double *gt = m_rails[k].gt();
409		const double *go = m_rails[k].go();
410	471	const double *Idr = m_rails[k].Idr();
	472	#if VECTALT
411	473
412	474	for (int i = 0; i < rails_count; i++)
413	475	{
414	476	rhsk = rhsk + Idr[i];
415	477	akk = akk + gt[i];
	478	}
	479	#else
	480	m_rails[k].ops()->sum2(Idr, gt, rhsk, akk);
	481	//rhsk += sum(m_rails[k].Idr(), rails_count);
	482	//akk += sum(m_rails[k].gt(), rails_count);
	483	#endif
	484	const double *go = m_rails[k].go();
	485	for (int i = 0; i < rails_count; i++)
	486	{
416	487	rhsk = rhsk + go[i] * rails[i]->m_otherterm->net().as_analog().Q_Analog();
417	488	}
418	489	}
419		m_RHS[k] = rhsk;
420		m_A[k][k] += akk;
	490	/*
	491	* Matrix preconditioning with 1.0 / Akk
	492	*
	493	* will save a number of calculations during elimination
	494	*
	495	*/
	496	akk = 1.0 / akk;
	497	m_RHS[k] = rhsk * akk;
	498	m_A[k][k] += 1.0;
	499	{
	500	const int terms_count = m_terms[k].count();
	501	//const netlist_terminal_t * const *terms = m_terms[k].terms();
	502	const int *net_other = m_terms[k].net_other();
	503	const double *go = m_terms[k].go();
	504
	505	for (int i = 0; i < terms_count; i++)
	506	{
	507	m_A[k][net_other[i]] += -go[i] * akk;
	508	}
	509	}
421	510	}
422	511	}
423	512
r30754	r30755
466	555
467	556	for (int j = i + 1; j < kN; j++)
468	557	{
469		const double f1 = m_A[j][i] * f;
	558	const double f1 = - m_A[j][i] * f;
470	559	if (f1 != 0.0)
471	560	{
472	561	for (int k = i + 1; k < kN; k++)
473		m_A[j][k] -= m_A[i][k] * f1;
474		m_RHS[j] -= m_RHS[i] * f1;
	562	m_A[j][k] += m_A[i][k] * f1;
	563	m_RHS[j] += m_RHS[i] * f1;
475	564	}
476	565	}
477	566	}
r30754	r30755
480	569	{
481	570	//__builtin_prefetch(&m_A[j-1][j], 0);
482	571	double tmp = 0;
483		for (int k = j + 1; k < kN; k++)
	572
	573	for (int k = j + 1; k < kN; k++)
484	574	tmp += m_A[j][k] * x[k];
485		x[j] = (m_RHS[j] - tmp) / m_A[j][j];
	575
	576	x[j] = (m_RHS[j] - tmp) / m_A[j][j];
486	577	}
487	578	#if 0
488	579	printf("Solution:\n");
r30754	r30755
627	718	// netlist_matrix_solver - Gauss - Seidel
628	719	// ----------------------------------------------------------------------------------------
629	720
630		template<int _N>
631		static inline const double sum(const double *v)
632		{
633		double tmp = 0.0;
634		for (int i=0; i < _N; i++)
635		tmp += v[i];
636		return tmp;
637		}
638
639		template<int _N>
640		static inline const double sumabs(const double *v)
641		{
642		double tmp = 0.0;
643		for (int i=0; i < _N; i++)
644		tmp += fabs(v[i]);
645		return tmp;
646		}
647
648	721	template <int m_N, int _storage_N>
649	722	ATTR_HOT int netlist_matrix_solver_gauss_seidel_t<m_N, _storage_N>::vsolve_non_dynamic()
650	723	{
r30754	r30755
713	786	#else
714	787	const int iN = this->N();
715	788	bool resched = false;
716
717	789	int  resched_cnt = 0;
718		ATTR_UNUSED netlist_net_t *last_resched_net = NULL;
719	790
720	791	/* over-relaxation not really works on these matrices */
721	792	//const double w = 1.0; //2.0 / (1.0 + sin(3.14159 / (m_nets.count()+1)));
r30754	r30755
741	812	const netlist_terminal_t * const * rails = this->m_rails[k].terms();
742	813	//const int * othernet = this->m_rails[k].m_othernet;
743	814	const int rail_count = this->m_rails[k].count();
744		const double *gt = this->m_rails[k].gt();
	815	double *gt = this->m_rails[k].gt();
745	816	const double *go = this->m_rails[k].go();
746	817	const double *Idr = this->m_rails[k].Idr();
747
	818	#if VECTALT
748	819	for (int i = 0; i < rail_count; i++)
749	820	{
750		RHS_t += go[i] * rails[i]->m_otherterm->net().as_analog().Q_Analog();
751	821	gtot_t += gt[i];
752	822	gabs_t += fabs(go[i]);
753	823	RHS_t += Idr[i];
754		// this may point to a rail net ...
	824	RHS_t += go[i] * rails[i]->m_otherterm->net().as_analog().Q_Analog();
755	825	}
	826	#else
	827	this->m_rails[k].ops()->sum2a(gt, Idr, go, gtot_t, RHS_t, gabs_t);
	828
	829	for (int i = 0; i < rail_count; i++)
	830	RHS_t += go[i] * rails[i]->m_otherterm->net().as_analog().Q_Analog();
	831	#endif
756	832	}
757	833	{
758	834	const int term_count = this->m_terms[k].count();
759	835	const double *gt = this->m_terms[k].gt();
760	836	const double *go = this->m_terms[k].go();
761	837	const double *Idr = this->m_terms[k].Idr();
762
	838	#if VECTALT
763	839	for (int i = 0; i < term_count; i++)
764	840	{
765	841	gtot_t += gt[i];
766	842	gabs_t += fabs(go[i]);
767	843	RHS_t += Idr[i];
768	844	}
	845	#else
	846	this->m_terms[k].ops()->sum2a(gt, Idr, go, gtot_t, RHS_t, gabs_t);
	847	#endif
769	848	}
770		gabs_t *= 1.0;
771		if (gabs_t > gtot_t)
	849	RHS[k] = RHS_t;
	850
	851	gabs_t *= 0.9; // avoid rounding issues
	852	if (gabs_t <= gtot_t)
772	853	{
773		w[k] = 1.0 / (gtot_t + gabs_t);
774		one_m_w[k] = 1.0 - 1.0 * gtot_t / (gtot_t + gabs_t);
	854	const double ws = 1.0;
	855	w[k] = ws / gtot_t;
	856	one_m_w[k] = 1.0 - ws;
775	857	}
776	858	else
777	859	{
778		const double ws = 1.0;
779		w[k] = ws / gtot_t;
780		one_m_w[k] = 1.0 - ws;
	860	w[k] = 1.0 / (gtot_t + gabs_t);
	861	one_m_w[k] = 1.0 - 1.0 * gtot_t / (gtot_t + gabs_t);
781	862	}
782	863
783		RHS[k] = RHS_t;
784	864	}
785	865
786	866	do {
r30754	r30755
815	895	} while (resched && (resched_cnt < this->m_params.m_gs_loops));
816	896
817	897	for (int k = 0; k < iN; k++)
818		{
819	898	this->m_nets[k]->m_new_Analog = this->m_nets[k]->m_cur_Analog = new_V[k];
820		}
821	899
	900	this->m_gs_total += resched_cnt;
822	901
823		this->m_gs_total += resched_cnt;
824	902	if (resched)
825	903	{
826	904	//this->netlist().warning("Falling back to direct solver .. Consider increasing RESCHED_LOOPS");
r30754	r30755
832	910	else {
833	911	this->m_calculations++;
834	912
835		//for (int k = 0; k < this->N(); k++)
836		//    this->m_nets[k]->m_cur_Analog = this->m_nets[k]->m_new_Analog;
837
838	913	return resched_cnt;
839	914	}
840	915	#endif
r30754	r30755
1010	1085
1011	1086	switch (net_count)
1012	1087	{
	1088	#if 1
1013	1089	case 1:
1014	1090	ms = create_solver<1,1>(gs_threshold, use_specific);
1015	1091	break;
r30754	r30755
1034	1110	case 8:
1035	1111	ms = create_solver<8,8>(gs_threshold, use_specific);
1036	1112	break;
	1113	case 12:
	1114	ms = create_solver<12,12>(gs_threshold, use_specific);
	1115	break;
	1116	#endif
1037	1117	default:
1038	1118	if (net_count <= 16)
1039	1119	{

trunk/src/emu/netlist/analog/nld_solver.h

r30754	r30755
40	40	netlist_time m_nt_sync_delay;
41	41	};
42	42
43		class ATTR_ALIGNED(64) netlist_matrix_solver_t : public netlist_device_t
	43	class vector_t
44	44	{
45	45	public:
	46
	47	vector_t(int size)
	48	: m_dim(size)
	49	{
	50	}
	51
	52	virtual ~vector_t() {}
	53
	54	ATTR_ALIGNED(64) double * RESTRICT  m_V;
	55
	56	virtual const double sum(const double * v) = 0;
	57	virtual void sum2(const double * v1, const double * v2, double &s1, double &s2) = 0;
	58	virtual void sum2a(const double * v1, const double * v2, const double * v3abs, double &s1, double &s2, double &s3abs) = 0;
	59
	60	virtual const double sumabs(const double * v) = 0;
	61
	62	protected:
	63	int m_dim;
	64
	65	private:
	66
	67	};
	68
	69	template <int m_N>
	70	class vector_imp_t : public vector_t
	71	{
	72	public:
	73
	74	vector_imp_t()
	75	: vector_t(m_N)
	76	{
	77	}
	78
	79	vector_imp_t(int size)
	80	: vector_t(size)
	81	{
	82	assert(m_N == 0);
	83	}
	84
	85	virtual ~vector_imp_t() {}
	86
	87	ATTR_HOT inline const int N() const { if (m_N == 0) return m_dim; else return m_N; }
	88
	89	const double sum(const double * v)
	90	{
	91	const double * RESTRICT vl = v;
	92	double tmp = 0.0;
	93	for (int i=0; i < N(); i++)
	94	tmp += vl[i];
	95	return tmp;
	96	}
	97
	98	void sum2(const double * v1, const double * v2, double &s1, double &s2)
	99	{
	100	const double * RESTRICT v1l = v1;
	101	const double * RESTRICT v2l = v2;
	102	for (int i=0; i < N(); i++)
	103	{
	104	s1 += v1l[i];
	105	s2 += v2l[i];
	106	}
	107	}
	108
	109	void sum2a(const double * v1, const double * v2, const double * v3abs, double &s1, double &s2, double &s3abs)
	110	{
	111	const double * RESTRICT v1l = v1;
	112	const double * RESTRICT v2l = v2;
	113	const double * RESTRICT v3l = v3abs;
	114	for (int i=0; i < N(); i++)
	115	{
	116	s1 += v1l[i];
	117	s2 += v2l[i];
	118	s3abs += fabs(v3l[i]);
	119	}
	120	}
	121
	122	const double sumabs(const double * v)
	123	{
	124	const double * RESTRICT vl = v;
	125	double tmp = 0.0;
	126	for (int i=0; i < N(); i++)
	127	tmp += fabs(vl[i]);
	128	return tmp;
	129	}
	130
	131	private:
	132	};
	133
	134	class ATTR_ALIGNED(64) terms_t
	135	{
	136	public:
	137	ATTR_COLD terms_t() {}
	138
	139	ATTR_COLD void clear()
	140	{
	141	m_term.clear();
	142	m_net_other.clear();
	143	m_gt.clear();
	144	}
	145
	146	ATTR_COLD void add(netlist_terminal_t *term, int net_other);
	147
	148	ATTR_HOT inline int count() { return m_term.count(); }
	149
	150	ATTR_HOT inline netlist_terminal_t **terms() { return m_term; }
	151	ATTR_HOT inline int *net_other() { return m_net_other; }
	152	ATTR_HOT inline double *gt() { return m_gt; }
	153	ATTR_HOT inline double *go() { return m_go; }
	154	ATTR_HOT inline double *Idr() { return m_Idr; }
	155	ATTR_HOT vector_t *ops() { return m_ops; }
	156
	157	ATTR_COLD void set_pointers();
	158
	159	private:
	160	plinearlist_t<netlist_terminal_t *> m_term;
	161	plinearlist_t<int> m_net_other;
	162	plinearlist_t<double> m_gt;
	163	plinearlist_t<double> m_go;
	164	plinearlist_t<double> m_Idr;
	165	vector_t * m_ops;
	166	};
	167
	168	class netlist_matrix_solver_t : public netlist_device_t
	169	{
	170	public:
46	171	typedef plinearlist_t<netlist_matrix_solver_t *> list_t;
47	172	typedef netlist_core_device_t::list_t dev_list_t;
48	173
r30754	r30755
53	178
54	179	ATTR_HOT double solve();
55	180
56		ATTR_HOT inline bool is_dynamic() { return m_dynamic.count() > 0; }
57		ATTR_HOT inline bool is_timestep() { return m_steps.count() > 0; }
	181	ATTR_HOT inline bool is_dynamic() { return m_dynamic_devices.count() > 0; }
	182	ATTR_HOT inline bool is_timestep() { return m_step_devices.count() > 0; }
58	183
59	184	ATTR_HOT void update_forced();
60	185
r30754	r30755
70	195
71	196	protected:
72	197
73		class ATTR_ALIGNED(64) terms_t{
74
75		public:
76		terms_t() {}
77
78		void clear()
79		{
80		m_term.clear();
81		m_net_other.clear();
82		m_gt.clear();
83		}
84
85		void add(netlist_terminal_t *term, int net_other)
86		{
87		m_term.add(term);
88		m_net_other.add(net_other);
89		m_gt.add(0.0);
90		m_go.add(0.0);
91		m_Idr.add(0.0);
92		}
93
94		inline int count() { return m_term.count(); }
95
96		inline netlist_terminal_t **terms() { return m_term; }
97		inline int *net_other() { return m_net_other; }
98		inline double *gt() { return m_gt; }
99		inline double *go() { return m_go; }
100		inline double *Idr() { return m_Idr; }
101
102		void set_pointers()
103		{
104		for (int i = 0; i < count(); i++)
105		{
106		m_term[i]->m_gt1 = &m_gt[i];
107		m_term[i]->m_go1 = &m_go[i];
108		m_term[i]->m_Idr1 = &m_Idr[i];
109		}
110		}
111
112		private:
113		plinearlist_t<netlist_terminal_t *> m_term;
114		plinearlist_t<int> m_net_other;
115		plinearlist_t<double> m_gt;
116		plinearlist_t<double> m_go;
117		plinearlist_t<double> m_Idr;
118
119		};
120
121	198	ATTR_COLD void setup(netlist_analog_net_t::list_t &nets);
122	199
123	200	// return true if a reschedule is needed ...
124	201	ATTR_HOT virtual int vsolve_non_dynamic() = 0;
125	202
126	203	ATTR_COLD virtual void  add_term(int net_idx, netlist_terminal_t *term) = 0;
127		int m_calculations;
128	204
129	205	plinearlist_t<netlist_analog_net_t *> m_nets;
130	206	plinearlist_t<netlist_analog_output_t *> m_inps;
131	207
	208	int m_calculations;
	209
132	210	private:
133	211
134	212	netlist_time m_last_step;
135		dev_list_t m_steps;
136		dev_list_t m_dynamic;
	213	dev_list_t m_step_devices;
	214	dev_list_t m_dynamic_devices;
137	215
138	216	netlist_ttl_input_t m_fb_sync;
139	217	netlist_ttl_output_t m_Q_sync;
r30754	r30755
159	237	netlist_matrix_solver_direct_t()
160	238	: netlist_matrix_solver_t()
161	239	, m_dim(0)
162		{}
	240	{
	241	for (int k=0; k<_storage_N; k++)
	242	m_A[k] = & m_A_phys[k][0];
	243	}
163	244
164	245	virtual ~netlist_matrix_solver_direct_t() {}
165	246
r30754	r30755
173	254
174	255	ATTR_HOT virtual int vsolve_non_dynamic();
175	256	ATTR_HOT int solve_non_dynamic();
176		ATTR_HOT inline void build_LE();
177		ATTR_HOT inline void gauss_LE(double (* RESTRICT x));
178		ATTR_HOT inline double delta(
179		const double (* RESTRICT V));
180		ATTR_HOT inline void store(const double (* RESTRICT V), const bool store_RHS);
	257	ATTR_HOT void build_LE();
	258	ATTR_HOT void gauss_LE(double (* RESTRICT x));
	259	ATTR_HOT double delta(const double (* RESTRICT V));
	260	ATTR_HOT void store(const double (* RESTRICT V), const bool store_RHS);
181	261
182	262	ATTR_HOT virtual double compute_next_timestep(const double);
183	263
184		ATTR_ALIGNED(64) double m_A[_storage_N][_storage_N];
	264	ATTR_ALIGNED(64) double * RESTRICT m_A[_storage_N];
185	265	ATTR_ALIGNED(64) double m_RHS[_storage_N];
186	266	ATTR_ALIGNED(64) double m_last_RHS[_storage_N]; // right hand side - contains currents
187	267
188	268	terms_t m_terms[_storage_N];
189	269	terms_t m_rails[_storage_N];
190		plinearlist_t<double> xx[_storage_N];
191	270
192	271	private:
	272	ATTR_ALIGNED(64) double m_A_phys[_storage_N][((_storage_N + 7) / 8) * 8];
193	273
194	274	int m_dim;
195	275	};

trunk/src/emu/netlist/plists.h

r30754	r30755
182	182	}
183	183
184	184	int m_count;
185		_ListClass * m_list;
	185	_ListClass * m_list /* ATTR_ALIGN */;
186	186	int m_num_elements;
187	187	};
188	188

Previous

199869 Revisions

Next

---

© 1997-2024 The MAME Team