Context Navigation

source: Sophya/trunk/AddOn/TAcq/racqumem.cc@ 3974

Visit:

Last change on this file since 3974 was 3958, checked in by ansari, 15 years ago
correction bug ds RAcqMemZoneMgr, taille fiber_id, Reza 03/03/2011
File size: 12.9 KB

Rev	Line
[3537]	1	#include "racqumem.h"
	2
[3683]	3	using namespace SOPHYA;
	4
[3537]	5	//----------------------------------------------------------------
	6	// ---- classes de gestion memoire pour acquisition BAORadio -----
	7	// LAL - R. Ansari - Juin/Juillet 2008
	8	//----------------------------------------------------------------
	9
[3626]	10	/* --Methode-- */
[3658]	11	RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nz, uint_4 np, uint_4 psz)
[3958]	12	: mex(true), nzones(nz), nfibres(1), npaq(np), paqsz(psz), procpaqsz(0),
	13	fiber_id(1), stop_(false), runstate_(MemZR_Running)
[3537]	14	{
[3658]	15	Init();
	16	}
	17
	18	/* --Methode-- */
	19	RAcqMemZoneMgr::RAcqMemZoneMgr(uint_4 nzon, uint_4 nfib, uint_4 npaq, uint_4 paqsz, uint_4 procsz)
	20	: mex(true), nzones(nzon), nfibres(nfib), npaq(npaq), paqsz(paqsz), procpaqsz(procsz),
[3958]	21	fiber_id(nfib), stop_(false), runstate_(MemZR_Running)
[3658]	22	{
	23	Init();
	24	}
	25
	26	/* --Methode-- */
	27	void RAcqMemZoneMgr::Init()
	28	{
[3537]	29	St_MemZ st;
[3623]	30
[3626]	31	st.serial = 0;
[3537]	32	st.act = (uint_4)MemZA_None;
[3626]	33	st.stat = (uint_4)MemZS_Free;
[3683]	34	for(int k=0; k<MXNACTMZM; k++) st.nbact[k] = 0;
[3658]	35	uint_8 mzsz = nfibresnpaqpaqsz;
	36	uint_8 procmzsz = nfibresnpaqprocpaqsz;
[3537]	37
[3958]	38	for(unsigned int k=0; k<NbZones(); k++) {
	39	memzones.push_back(new Byte[mzsz] );
	40	states.push_back(st);
	41	auxdatap.push_back(new RAcqMZAuxData );
	42	if (procmzsz > 0) procmemzones.push_back(new Byte[procmzsz] );
	43	}
	44	for(size_t k=0; k<NbFibres(); k++) fiber_id[k]=0;
[3909]	45	dummy_=0;
[3626]	46	serial_ = 0;
	47	SetFinalizedMask();
[3683]	48	SetProcSavedReadyMask();
[3537]	49	}
	50
[3626]	51	/* --Methode-- */
[3537]	52	RAcqMemZoneMgr::~RAcqMemZoneMgr()
	53	{
[3658]	54	for(uint_4 k=0; k<NbZones(); k++) {
	55	delete[] memzones[k];
[3909]	56	delete auxdatap[k];
[3658]	57	if (procpaqsz > 0) delete[] procmemzones[k];
	58	}
[3537]	59	}
	60
[3626]	61	/* --Methode-- */
[3537]	62	int RAcqMemZoneMgr::FindMemZoneId(MemZaction act)
[3626]	63	// Recherche et renvoie une zone memoire compatible pour effectuer l'operation act
	64	// Pour act = MemZA_Fill : Zone vide ou satisfaisant la condition mask_finalized_
	65	// On recherche a chaque fois la zone ayant le plus petit numero de serie
	66	// cad le numero d'ordre de remplissage
	67	// Pour ProcA/B/C on attend que la zone avec le plus petit numero soit disponible
	68
[3537]	69	{
	70	int rid = -1;
	71	if (stop_) return rid;
[3635]	72	if ((act != MemZA_Fill) && (act != MemZA_Save) && (act != MemZA_Proc) &&
[3779]	73	(act != MemZA_ProcA) && (act != MemZA_ProcB) && (act != MemZA_ProcC) &&
	74	(act != MemZA_ProcD) && (act != MemZA_ProcE) && (act != MemZA_ProcF) &&
[3955]	75	(act != MemZA_ProcG) && (act != MemZA_ProcH) && (act != MemZA_ProcI) &&
	76	(act != MemZA_ProcJ) &&
[3779]	77	(act != MemZA_SaveProc) ) return rid;
	78
[3537]	79	mex.lock();
[3626]	80	uint_8 bestserial = serial_ + 5;
[3537]	81	while ((rid < 0)&&(!stop_)) {
[3626]	82	switch (act) {
[3623]	83	case MemZA_Fill:
	84	if (rid < 0) for(uint_4 k=0; k<NbZones(); k++) {
	85	if ((states[k].act == MemZA_None) &&
[3640]	86	((states[k].stat == MemZS_Free)\|\|((states[k].stat&mask_finalized_)==mask_finalized_) )) {
[3626]	87	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	88	}
[3623]	89	}
	90	if (rid >= 0) { states[rid].act = MemZA_Fill; states[rid].stat = MemZS_Free; }
	91	break;
	92	case MemZA_Save:
	93	for(uint_4 k=0; k<NbZones(); k++) {
[3626]	94	if ((states[k].act == MemZA_None) &&
	95	(states[k].stat & MemZS_Filled) && !(states[k].stat & MemZS_Saved) ) {
	96	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	97	}
[3623]	98	}
	99	if (rid >= 0) states[rid].act = MemZA_Save;
	100	break;
	101	case MemZA_Proc:
	102	for(uint_4 k=0; k<NbZones(); k++) {
[3626]	103	if ((states[k].act == MemZA_None) &&
[3671]	104	(states[k].stat & MemZS_Saved) && !(states[k].stat & MemZS_Proc) ) {
[3626]	105	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	106	}
	107	}
	108	if (rid >= 0) states[rid].act = MemZA_Proc;
	109	break;
	110	case MemZA_ProcA:
	111	for(uint_4 k=0; k<NbZones(); k++) {
[3623]	112	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
[3626]	113	!(states[k].stat & MemZS_ProcA) ) {
	114	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	115	}
[3623]	116	}
[3626]	117	if (rid >= 0) states[rid].act = MemZA_ProcA;
[3623]	118	break;
[3626]	119	case MemZA_ProcB:
	120	for(uint_4 k=0; k<NbZones(); k++) {
	121	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	122	(states[k].stat & MemZS_ProcA) && !(states[k].stat & MemZS_ProcB) ) {
	123	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	124	}
	125	}
	126	if (rid >= 0) states[rid].act = MemZA_ProcB;
	127	break;
	128	case MemZA_ProcC:
	129	for(uint_4 k=0; k<NbZones(); k++) {
	130	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	131	(states[k].stat & MemZS_ProcB) && !(states[k].stat & MemZS_ProcC) ) {
	132	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	133	}
	134	}
	135	if (rid >= 0) states[rid].act = MemZA_ProcC;
	136	break;
[3683]	137	case MemZA_ProcD:
	138	for(uint_4 k=0; k<NbZones(); k++) {
	139	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	140	(states[k].stat & MemZS_ProcC) && !(states[k].stat & MemZS_ProcD) ) {
	141	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	142	}
	143	}
	144	if (rid >= 0) states[rid].act = MemZA_ProcD;
	145	break;
	146	case MemZA_ProcE:
	147	for(uint_4 k=0; k<NbZones(); k++) {
	148	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	149	(states[k].stat & MemZS_ProcD) && !(states[k].stat & MemZS_ProcE) ) {
	150	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	151	}
	152	}
	153	if (rid >= 0) states[rid].act = MemZA_ProcE;
	154	break;
	155	case MemZA_ProcF:
	156	for(uint_4 k=0; k<NbZones(); k++) {
	157	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	158	(states[k].stat & MemZS_ProcE) && !(states[k].stat & MemZS_ProcF) ) {
	159	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	160	}
	161	}
	162	if (rid >= 0) states[rid].act = MemZA_ProcF;
	163	break;
[3955]	164	case MemZA_ProcG:
	165	for(uint_4 k=0; k<NbZones(); k++) {
	166	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	167	(states[k].stat & MemZS_ProcF) && !(states[k].stat & MemZS_ProcG) ) {
	168	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	169	}
	170	}
	171	if (rid >= 0) states[rid].act = MemZA_ProcG;
	172	break;
	173	case MemZA_ProcH:
	174	for(uint_4 k=0; k<NbZones(); k++) {
	175	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	176	(states[k].stat & MemZS_ProcG) && !(states[k].stat & MemZS_ProcH) ) {
	177	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	178	}
	179	}
	180	if (rid >= 0) states[rid].act = MemZA_ProcH;
	181	break;
	182	case MemZA_ProcI:
	183	for(uint_4 k=0; k<NbZones(); k++) {
	184	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	185	(states[k].stat & MemZS_ProcH) && !(states[k].stat & MemZS_ProcI) ) {
	186	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	187	}
	188	}
	189	if (rid >= 0) states[rid].act = MemZA_ProcI;
	190	break;
	191	case MemZA_ProcJ:
	192	for(uint_4 k=0; k<NbZones(); k++) {
	193	if ((states[k].act == MemZA_None) && (states[k].stat & MemZS_Filled) &&
	194	(states[k].stat & MemZS_ProcI) && !(states[k].stat & MemZS_ProcJ) ) {
	195	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	196	}
	197	}
	198	if (rid >= 0) states[rid].act = MemZA_ProcJ;
	199	break;
[3683]	200	case MemZA_SaveProc:
	201	for(uint_4 k=0; k<NbZones(); k++) {
	202	if ((states[k].act == MemZA_None) &&
	203	(states[k].stat & mask_saveproc_ready_) && !(states[k].stat & MemZS_SavedProc) ) {
	204	if (states[k].serial < bestserial) { rid=k; bestserial=states[k].serial; }
	205	}
	206	}
	207	if (rid >= 0) states[rid].act = MemZA_SaveProc;
	208	break;
[3623]	209	case MemZA_None: // MTQ pour supprimer un warning
	210	break;
[3626]	211	} // Fin de switch
[3623]	212	if (rid < 0) mex.wait();
[3626]	213	} // Fin de while
[3537]	214	mex.unlock();
	215	return rid;
	216	}
	217
[3626]	218	/* --Methode-- */
[3537]	219	int RAcqMemZoneMgr::FreeMemZone(int id, MemZStatus st)
	220	{
[3623]	221	if ((id < 0) \|\| (id >= (int)states.size())) return 1;
[3537]	222	int rc = 0;
	223	mex.lock();
	224	switch (st) {
[3626]	225	case MemZS_Free :
	226	states[id].serial = 0;
	227	states[id].stat = MemZS_Free;
	228	states[id].act = MemZA_None;
	229	break;
	230	case MemZS_Filled :
	231	if (states[id].act != MemZA_Fill) rc = 2;
	232	else states[id].nbact[0]++;
	233	serial_ ++;
	234	states[id].serial = serial_;
	235	states[id].stat \|= MemZS_Filled;
	236	states[id].act = MemZA_None;
	237	break;
	238	case MemZS_Saved :
	239	if (states[id].act != MemZA_Save) rc = 4;
	240	else states[id].nbact[1]++;
	241	states[id].stat \|= MemZS_Saved;
	242	states[id].act = MemZA_None;
	243	break;
	244	case MemZS_Proc :
	245	if (states[id].act != MemZA_Proc) rc = 8;
	246	else states[id].nbact[2]++;
	247	states[id].stat \|= MemZS_Proc;
	248	states[id].act = MemZA_None;
	249	break;
	250	case MemZS_ProcA :
	251	if (states[id].act != MemZA_ProcA) rc = 16;
	252	else states[id].nbact[3]++;
	253	states[id].stat \|= MemZS_ProcA;
	254	states[id].act = MemZA_None;
	255	break;
	256	case MemZS_ProcB :
	257	if (states[id].act != MemZA_ProcB) rc = 32;
	258	else states[id].nbact[4]++;
	259	states[id].stat \|= MemZS_ProcB;
	260	states[id].act = MemZA_None;
	261	break;
	262	case MemZS_ProcC :
	263	if (states[id].act != MemZA_ProcC) rc = 64;
[3683]	264	else states[id].nbact[5]++;
[3626]	265	states[id].stat \|= MemZS_ProcC;
	266	states[id].act = MemZA_None;
	267	break;
[3683]	268	case MemZS_ProcD :
	269	if (states[id].act != MemZA_ProcD) rc = 128;
	270	else states[id].nbact[6]++;
	271	states[id].stat \|= MemZS_ProcD;
	272	states[id].act = MemZA_None;
	273	break;
	274	case MemZS_ProcE :
	275	if (states[id].act != MemZA_ProcE) rc = 256;
	276	else states[id].nbact[7]++;
	277	states[id].stat \|= MemZS_ProcE;
	278	states[id].act = MemZA_None;
	279	break;
	280	case MemZS_ProcF :
	281	if (states[id].act != MemZA_ProcF) rc = 512;
	282	else states[id].nbact[8]++;
	283	states[id].stat \|= MemZS_ProcF;
	284	states[id].act = MemZA_None;
	285	break;
[3955]	286	case MemZS_ProcG :
	287	if (states[id].act != MemZA_ProcG) rc = 1024;
	288	else states[id].nbact[9]++;
	289	states[id].stat \|= MemZS_ProcG;
	290	states[id].act = MemZA_None;
	291	break;
	292	case MemZS_ProcH :
	293	if (states[id].act != MemZA_ProcH) rc = 2048;
	294	else states[id].nbact[10]++;
	295	states[id].stat \|= MemZS_ProcH;
	296	states[id].act = MemZA_None;
	297	break;
	298	case MemZS_ProcI :
	299	if (states[id].act != MemZA_ProcI) rc = 4096;
	300	else states[id].nbact[11]++;
	301	states[id].stat \|= MemZS_ProcI;
	302	states[id].act = MemZA_None;
	303	break;
	304	case MemZS_ProcJ :
	305	if (states[id].act != MemZA_ProcJ) rc = 4096;
	306	else states[id].nbact[12]++;
	307	states[id].stat \|= MemZS_ProcJ;
	308	states[id].act = MemZA_None;
	309	break;
[3683]	310	case MemZS_SavedProc :
[3955]	311	if (states[id].act != MemZA_SaveProc) rc = 16384;
	312	else states[id].nbact[13]++;
[3683]	313	states[id].stat \|= MemZS_ProcF;
	314	states[id].act = MemZA_None;
	315	break;
[3626]	316	default :
[3683]	317	rc = 65536;
[3626]	318	states[id].serial = 0;
	319	states[id].stat = MemZS_Free;
	320	states[id].act = MemZA_None;
	321	break;
	322	} // Fin de switch
[3537]	323	mex.unlock();
	324	mex.broadcast();
	325	return rc;
	326	}
	327
[3913]	328	/* --Methode-- */
[3537]	329	ostream& RAcqMemZoneMgr::Print(ostream& os)
	330	{
	331	os << "RAcqMemZoneMgr::Print() NbZones=" << NbZones() << " PaqSize()=" << PaqSize()
[3958]	332	<< " NbPaquets()=" << NbPaquets() << " NbFibres()=" << NbFibres() << " ZoneSize()="
	333	<< ZoneSize() << endl;
[3635]	334	if (ProcPaqSize() > 0)
	335	cout << " ... With Processed Data Zones ProcPaqSize()=" << ProcPaqSize()
	336	<< " ProcZoneSize()=" << ProcZoneSize() << endl;
	337	else cout << " ... NO Processed Data Zones" << endl;
[3683]	338	for(uint_4 k=0; k<states.size(); k++) {
[3537]	339	os << " [" << k << "] Act=" << states[k].act << " Stat=" << states[k].stat
[3683]	340	<< " NbAct[0.."<< MXNACTMZM-1 << "]=" << states[k].nbact[0];
	341	for(uint_4 j=1; j<MXNACTMZM; j++) cout << "," << states[k].nbact[j];
	342	cout << endl;
	343	}
[3537]	344	return os;
	345	}
	346
[3913]	347	/* --Methode-- */
[3537]	348	void RAcqMemZoneMgr::Stop()
	349	{
[3623]	350	// cout << "RAcqMemZoneMgr::Stop() ........ STOP BROADCAST" <<endl;
[3537]	351	stop_ = true;
[3658]	352	runstate_ = MemZR_Stopped;
[3537]	353	mex.broadcast();
	354	}
[3913]	355
	356	/* --Methode-- */
	357	MemZaction RAcqMemZoneMgr::Convert_Status2Action(MemZStatus st)
	358	// methode statique
	359	{
	360	MemZaction ra=MemZA_None;
	361	switch (st) {
	362	case MemZS_Filled:
	363	ra=MemZA_Fill;
	364	break;
	365	case MemZS_Saved:
	366	ra=MemZA_Save;
	367	break;
	368	case MemZS_Proc:
	369	ra=MemZA_Proc;
	370	break;
	371	case MemZS_ProcA:
	372	ra=MemZA_ProcA;
	373	break;
	374	case MemZS_ProcB:
	375	ra=MemZA_ProcB;
	376	break;
	377	case MemZS_ProcC:
	378	ra=MemZA_ProcC;
	379	break;
	380	case MemZS_ProcD:
	381	ra=MemZA_ProcD;
	382	break;
	383	case MemZS_ProcE:
	384	ra=MemZA_ProcE;
	385	break;
	386	case MemZS_ProcF:
	387	ra=MemZA_ProcF;
	388	break;
	389	default:
	390	ra=MemZA_None;
	391	break;
	392	}
	393	return ra;
	394	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: