Context Navigation

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

Visit:

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

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

Download in other formats: