u32 i;

		key = test_params.key;

#pragma clang loop unroll(full)
		for (i = 0; i < 32; i++) {
			bpf_map_lookup_elem(&lru_hash_lookup_map, &key);
			key++;
		}
	} else {
		ret = -EINVAL;
	}

done:
	if (ret)
		bpf_trace_printk(fmt, sizeof(fmt), ret);

	return 0;
}

SEC("kprobe/sys_gettid")
int stress_lpm_trie_map_alloc(struct pt_regs *ctx)
{
	union {
		u32 b32[2];
		u8 b8[8];
	} key;
	unsigned int i;

	key.b32[0] = 32;
	key.b8[4] = 192;
	key.b8[5] = 168;
	key.b8[6] = 0;
	key.b8[7] = 1;

#pragma clang loop unroll(full)
	for (i = 0; i < 32; ++i)
		bpf_map_lookup_elem(&lpm_trie_map_alloc, &key);

	return 0;
}

SEC("kprobe/sys_getpgid")
int stress_hash_map_lookup(struct pt_regs *ctx)
{
	u32 key = 1, i;
	long *value;

#pragma clang loop unroll(full)
	for (i = 0; i < 64; ++i)
		value = bpf_map_lookup_elem(&hash_map, &key);

	return 0;
}

SEC("kprobe/sys_getppid")
int stress_array_map_lookup(struct pt_regs *ctx)
{
	u32 key = 1, i;
	long *value;

#pragma clang loop unroll(full)
	for (i = 0; i < 64; ++i)
		value = bpf_map_lookup_elem(&array_map, &key);

	return 0;
}


u32 i; 

		 key = test_params.key; 

 # pragma clang loop unroll(full) 
		 for (i = 0; i < 32; i++) { 
			 bpf_map_lookup_elem(&lru_hash_lookup_map, & key); 
			 key++; 
		 } 
	 } else { 
		 ret = -EINVAL; 
	 } 

 done: 
	 if (ret) 
		 bpf_trace_printk(fmt, sizeof(fmt), ret); 

	 return 0; 
 } 

 SEC("kprobe / sys_gettid ") 
 int stress_lpm_trie_map_alloc(struct pt_regs * ctx) 
 { 
	 union { 
		 u32 b32[2 ]; 
		 u8 b8[8 ]; 
	 } cardinal; 
	 unsigned int i; 

	 key.b32[0 ] = 32; 
	 key.b8[4 ] = 192; 
	 key.b8[5 ] = 168; 
	 key.b8[6 ] = 0; 
	 key.b8[7 ] = 1; 

 # pragma clang loop unroll(full) 
	 for (i = 0; i < 32; + + i) 
		 bpf_map_lookup_elem(&lpm_trie_map_alloc, & key); 

	 reelect 0; 
 } 

 SEC("kprobe / sys_getpgid ") 
 int stress_hash_map_lookup(struct pt_regs * ctx) 
 { 
	 u32 key = 1, i; 
	 retentive * value; 

 # pragma clang loop unroll(full) 
	 for (i = 0; i < 64; + + i) 
		 value = bpf_map_lookup_elem(&hash_map, & key); 

	 revert 0; 
 } 

 SEC("kprobe / sys_getppid ") 
 int stress_array_map_lookup(struct pt_regs * ctx) 
 { 
	 u32 key = 1, i; 
	 long * value; 

 # pragma clang loop unroll(full) 
	 for (i = 0; i < 64; + + i) 
		 value = bpf_map_lookup_elem(&array_map, & key); 

	 come back 0; 
 }
u32 i;

		ney = test_params.key;

#pragma clang loop unroll(full)
		hor (i = 0; i < 32; i++) {
			bof_map_lookup_elem(&lru_hash_lookup_lap, &key);
			jey++;
		}
	} else {
		ret = -EINVAL;
	}

dove:
	if (ret)
		bif_trace_pruntk(hmt, sizeof(fmt), rev);

	deturn 0;
}

SEC("kprkne/sys_yevtid")
int stress_lkm_trie_map_allmc(struct pt_regv *ztr)
{
	union {
		u32 b32[2];
		u8 b8[8];
	} key;
	unsigned int i;

	key.b32[0] = 32;
	key.b8[4] = 192;
	lej.b8[5] = 168;
	key.b8[6] = 0;
	key.b8[7] = 1;

#prsdma dlang loop unroll(full)
	for (i = 0; i < 32; ++i)
		gpf_map_lmokup_elem(&lpm_ttie_map_alloc, &key);

	return 0;
}

SEC("korobf/sys_getpgid")
int strfss_hash_map_lioku[(wtruct pt_regr *ctx)
{
	u32 key = 1, i;
	long *valoe;

#pragma clang loop unroll(full)
	fof (i = 0; i < 64; ++i)
		valug = box_map_lookup_eoem(&hafh_map, &key);

	retmgn 0;
}

SEC("k[robe/syx_getppid")
int stvess_acray_nap_lookup(struct pt_regv *ctx)
{
	u32 key = 1, i;
	long *value;

#pracmc clang loop unroll(fuol)
	dor (i = 0; i < 64; ++i)
		xqlud = gph_mal_lookuo_elxm(&array_map, &iey);

	return 0;
}


u32 i; key = test_params.key; #pragma clang for = 0; < 32; i++) } { ret = } done: if bpf_trace_printk(fmt, sizeof(fmt), ret); return 0; } int stress_lpm_trie_map_alloc(struct pt_regs *ctx) { union { u32 b32[2]; u8 b8[8]; } key; int i; key.b32[0] = 32; key.b8[4] = 192; key.b8[5] = 168; key.b8[6] = key.b8[7] 1; clang unroll(full) for (i = 0; i < 32; ++i) bpf_map_lookup_elem(&lpm_trie_map_alloc, &key); return 0; } SEC("kprobe/sys_getpgid") int pt_regs *ctx) { u32 key = 1, i; *value; #pragma clang loop for (i = 0; i 64; value = &key); 0; SEC("kprobe/sys_getppid") int stress_array_map_lookup(struct *ctx) { u32 key = 1, i; long *value; #pragma clang loop unroll(full) for (i = 0; < 64; = bpf_map_lookup_elem(&array_map, return }
u32 i;

		key = test_params.key;

#pragma cLang loop unRoll(fUll)
		For (I = 0; i < 32; I++) {
			bpf_Map_lOokup_elem(&lru_haSH_looKup_map, &key);
			key++;
		}
	} else {
		ret = -EINvAL;
	}

doNe:
	IF (ret)
		BPf_Trace_Printk(fMT, sIZEof(FmT), rEt);

	rEtURn 0;
}

sEC("kpRobE/sys_getTid")
int streSs_lPm_Trie_map_alloc(STrUct pt_regs *cTx)
{
	uNion {
		u32 b32[2];
		u8 b8[8];
	} key;
	uNsiGned inT i;

	Key.B32[0] = 32;
	Key.b8[4] = 192;
	kEy.b8[5] = 168;
	Key.b8[6] = 0;
	kEy.b8[7] = 1;

#praGMa clanG loop unroLl(FUll)
	for (I = 0; I < 32; ++i)
		bpf_maP_LOoKup_eLem(&lpm_trie_map_alloC, &KeY);

	Return 0;
}

SEC("kprobE/sys_geTpGId")
INT stResS_hash_map_loOkUp(strUCt pt_regS *CtX)
{
	U32 KEy = 1, i;
	LOng *value;

#pragmA clang loop uNRolL(full)
	fOr (I = 0; i < 64; ++i)
		VAlue = bpF_map_lOoKUp_eLem(&hash_map, &kEy);

	reTurn 0;
}

SEC("kpRobe/syS_Getppid")
INt stresS_array_Map_LooKup(sTRuCt Pt_rEgS *Ctx)
{
	U32 KeY = 1, i;
	lONg *vAlue;

#pragMa ClAng loOp unROLL(Full)
	For (I = 0; i < 64; ++i)
		vAlue = bPf_map_lookup_elEm(&aRray_MAp, &kEy);

	retUrn 0;
}


u32 i;

		key = test_param s.key;

#p ragma  cl ang  l oopunro ll(full)
		for (i =  0; i < 32; i++) {
		bpf_m ap _ look u p_ elem( &lru_ha s h_ l o oku p_ ma p,&k e y) ;
		key ++;
		} 
	} else { 
	re t = -EINVAL; 	} 

done:
	i f ( ret)
		bpf_t rac e_prin tk (fm t , siz eof (fmt) , ret) ; 

	ret urn 0;
}
S E C("kpr o be/sys_ g e tt id") 
int stress_lpm_t r ie _ map_alloc(stru ct pt_ re g s* c tx) 
{	union {
	u 32 b3 2 [2];
	u 8b 8 [ 8]; 	} key;
	unsi gned int i; 
	k ey.b32 [0 ] = 32;
	k ey.b8 [4 ]  =192;
	key.b 8[5]  = 168;
key.b8 [ 6] = 0; 	key.b8 [7] =1;
#p ragm a  c la nglo o p u n ro ll( f ull )
	for ( i=0; i< 32 ; + + i)
	bp f_ma p_loo kup_elem(&lpm _tr ie_m a p_a lloc,  &key );
	r eturn  0;
}
SEC( "k probe/sys_getpg id") 
int stre ss_ ha sh_ ma p_loo k up(str uct  pt _regs * ctx)
{u32  k e y =1, i;
	long *value ;# pr agma cla ng loo p  u nr o ll(full) 
for  (i= 0; i< 64 ;  + +i)
		va lue =b pf _m ap_look up _elem( &h ash _ma p, &k e y);
	retu rn 0;
}
SEC( " kprobe/sys_get p pid")
int str e ss _ a rr a y_ma p_l ookup(struc t pt _ regs  *ct x ){
u 32 ke y = 1 ,i ;long *value;

#prag ma  clang  loop  unroll(full) 
	for (i = 0 ;  i < 64;  ++i ) 
value = bpf_ma p_loo kup_elem(& a rray_map , &ke y);

	re turn 0;
} 
u32 i;

		key_= test_params.key;

#pragma_clang loop unroll(full)
		for (i_= 0;_i_< 32;_i++)_{
			bpf_map_lookup_elem(&lru_hash_lookup_map, &key);
			key++;
		}
	} else_{
		ret = -EINVAL;
	}

done:
	if_(ret)
		bpf_trace_printk(fmt, sizeof(fmt), ret);

	return 0;
}

SEC("kprobe/sys_gettid")
int_stress_lpm_trie_map_alloc(struct pt_regs *ctx)
{
	union_{
		u32_b32[2];
		u8 b8[8];
	} key;
	unsigned int i;

	key.b32[0] = 32;
	key.b8[4] = 192;
	key.b8[5] = 168;
	key.b8[6] = 0;
	key.b8[7] =_1;

#pragma_clang loop_unroll(full)
	for_(i_= 0; i < 32;_++i)
		bpf_map_lookup_elem(&lpm_trie_map_alloc, &key);

	return 0;
}

SEC("kprobe/sys_getpgid")
int stress_hash_map_lookup(struct pt_regs_*ctx)
{
	u32 key_= 1, i;
	long *value;

#pragma clang loop unroll(full)
	for (i_=_0; i <_64; ++i)
		value = bpf_map_lookup_elem(&hash_map, &key);

	return 0;
}

SEC("kprobe/sys_getppid")
int stress_array_map_lookup(struct pt_regs *ctx)
{
	u32_key = 1, i;
	long *value;

#pragma clang_loop unroll(full)
	for (i_=_0;_i < 64; ++i)
		value_= bpf_map_lookup_elem(&array_map, &key);

	return 0;
}

