@@ -37,35 +37,20 @@ CsEraseBatch_AddDirect(PcctEraseBatch* peb, CsEntry* entry) {
37
37
CsEraseBatch_Append (peb , indirect , "indirect-dep" );
38
38
}
39
39
40
- switch (entry -> kind ) {
41
- case CsEntryNone :
42
- break ;
43
- case CsEntryMemory :
44
- CsEntry_FreeData (entry );
45
- break ;
46
- default :
47
- NDNDPDK_ASSERT (false);
48
- }
40
+ NDNDPDK_ASSERT (entry -> kind == CsEntryNone );
49
41
CsEraseBatch_Append (peb , entry , "direct" );
50
42
}
51
43
52
44
/** @brief Erase a CS entry including dependents. */
53
45
__attribute__((nonnull )) static void
54
46
Cs_EraseEntry (Cs * cs , CsEntry * entry ) {
55
47
PcctEraseBatch peb = PcctEraseBatch_New (Pcct_FromCs (cs ));
56
- switch (entry -> kind ) {
57
- case CsEntryIndirect :
58
- CsList_Remove (& cs -> indirect , entry );
59
- CsEraseBatch_AddIndirect (& peb , entry );
60
- break ;
61
- case CsEntryDisk :
62
- CsDisk_Delete (cs , entry );
63
- // fallthrough
64
- case CsEntryNone :
65
- case CsEntryMemory :
66
- CsArc_Remove (& cs -> direct , entry );
67
- CsEraseBatch_AddDirect (& peb , entry );
68
- break ;
48
+ if (entry -> kind == CsEntryIndirect ) {
49
+ CsList_Remove (& cs -> indirect , entry );
50
+ CsEraseBatch_AddIndirect (& peb , entry );
51
+ } else {
52
+ CsArc_Remove (& cs -> direct , entry );
53
+ CsEraseBatch_AddDirect (& peb , entry );
69
54
}
70
55
PcctEraseBatch_Finish (& peb );
71
56
}
@@ -147,14 +132,15 @@ Cs_PutDirect(Cs* cs, Packet* npkt, PccEntry* pccEntry) {
147
132
case CsEntryMemory :
148
133
CsEntry_FreeData (entry );
149
134
// fallthrough
135
+ case CsEntryDisk :
136
+ // diskSlot will be released by CsArc_Add that invokes CsDisk_ArcMove
137
+ // fallthrough
150
138
case CsEntryNone :
151
139
Cs_EraseImplicitDigestIndirect (cs , entry , data -> name .length );
152
140
break ;
153
141
case CsEntryIndirect :
154
142
CsEntry_Disassoc (entry );
155
143
break ;
156
- case CsEntryDisk : // TODO would this happen?
157
- NDNDPDK_ASSERT (false);
158
144
}
159
145
} else {
160
146
// insert direct entry
@@ -213,17 +199,6 @@ Cs_PutIndirect(Cs* cs, CsEntry* direct, PccEntry* pccEntry) {
213
199
} else {
214
200
// change direct entry to indirect entry
215
201
CsArc_Remove (& cs -> direct , entry );
216
- switch (entry -> kind ) {
217
- case CsEntryNone :
218
- break ;
219
- case CsEntryMemory :
220
- rte_pktmbuf_free (Packet_ToMbuf (entry -> data ));
221
- entry -> kind = CsEntryNone ;
222
- break ;
223
- case CsEntryDisk : // TODO would this happen?
224
- default :
225
- NDNDPDK_ASSERT (false);
226
- }
227
202
}
228
203
N_LOGD ("PutIndirect refresh cs=%p npkt=%p pcc-entry=%p cs-entry=%p" , cs , direct , pccEntry ,
229
204
entry );
@@ -261,36 +236,27 @@ Cs_Insert(Cs* cs, Packet* npkt, PitFindResult pitFound) {
261
236
PData * data = Packet_GetDataHdr (npkt );
262
237
PccEntry * pccEntry = pitFound .entry ;
263
238
PInterest * interest = PitFindResult_GetInterest (pitFound );
264
- CsEntry * direct = NULL ;
265
-
266
- // if Interest name differs from Data name, insert a direct entry elsewhere
267
- if (unlikely (interest -> name .nComps != data -> name .nComps )) {
268
- direct = Cs_InsertDirect (cs , npkt , interest );
269
- if (unlikely (direct == NULL )) { // direct entry insertion failed
270
- Pit_EraseSatisfied (& pcct -> pit , pitFound );
271
- rte_pktmbuf_free (pkt );
272
- if (likely (!pccEntry -> hasCsEntry )) {
273
- Pcct_Erase (pcct , pccEntry );
274
- }
275
- return ;
276
- }
277
- NULLize (npkt );
278
- NULLize (pkt ); // owned by direct entry
279
- }
280
239
281
- // delete PIT entries
282
- Pit_EraseSatisfied (& pcct -> pit , pitFound );
283
- NULLize (interest );
240
+ if ( interest -> name . nComps == data -> name . nComps ) { // exact match, direct entry here
241
+ Pit_EraseSatisfied (& pcct -> pit , pitFound );
242
+ NULLize (interest );
284
243
285
- if (likely (direct == NULL )) {
286
- // put direct CS entry at pccEntry
287
- direct = Cs_PutDirect (cs , npkt , pccEntry );
288
- // alloc-err cannot happen because PccSlots are freed from PIT entries
289
- NDNDPDK_ASSERT (direct != NULL ); // TODO this may happen now
290
- } else {
291
- // put indirect CS entry at pccEntry
244
+ CsEntry * direct = Cs_PutDirect (cs , npkt , pccEntry );
245
+ if (unlikely (direct == NULL )) {
246
+ goto FAIL_DIRECT ;
247
+ }
248
+ } else { // prefix match, indirect entry here, direct entry elsewhere
249
+ CsEntry * direct = Cs_InsertDirect (cs , npkt , interest );
250
+ Pit_EraseSatisfied (& pcct -> pit , pitFound );
251
+ NULLize (interest );
252
+
253
+ if (unlikely (direct == NULL )) {
254
+ goto FAIL_DIRECT ;
255
+ }
292
256
Cs_PutIndirect (cs , direct , pccEntry );
293
257
}
258
+ NULLize (npkt ); // owned by direct entry
259
+ NULLize (pkt );
294
260
295
261
// evict if over capacity
296
262
if (unlikely (cs -> indirect .count > cs -> indirect .capacity )) {
@@ -299,6 +265,13 @@ Cs_Insert(Cs* cs, Packet* npkt, PitFindResult pitFound) {
299
265
if (unlikely (cs -> direct .Del .count >= CsEvictBulk )) {
300
266
Cs_Evict (cs , & cs -> direct .Del , "direct" , Cs_EvictEntryDirect );
301
267
}
268
+
269
+ return ;
270
+ FAIL_DIRECT :
271
+ rte_pktmbuf_free (pkt );
272
+ if (likely (!pccEntry -> hasEntries )) {
273
+ Pcct_Erase (pcct , pccEntry );
274
+ }
302
275
}
303
276
304
277
CsEntry *
0 commit comments