Desc: Source code for RLC Unacknowledged mode assembly and
reassembly.This file contains following functions
- --kwUmmQSdu
- --kwUmmProcessSdus
- --kwUmmProcessPdus
- --kwUmmReAssembleSdus
+ --rlcUmmQSdu
+ --rlcUmmProcessSdus
+ --rlcUmmProcessPdus
+ --rlcUmmReAssembleSdus
--kwUmmReEstablish
File: kw_umm_dl.c
#include "kw_udx.x"
#include "kw_dl.x"
-#define KW_MODULE (KW_DBGMASK_UM | KW_DBGMASK_DL)
+#define RLC_MODULE (RLC_DBGMASK_UM | RLC_DBGMASK_DL)
/* variables for logging :declared in BRDCM cl */
#ifndef TENB_ACC
extern U32 dlrate_kwu;
#endif
-PRIVATE Void kwUmmEstHdrSz ARGS ((KwUmDl *umUl));
+PRIVATE Void rlcUmmEstHdrSz ARGS ((RlcUmDl *umUl));
-PRIVATE Void kwUmmCreatePdu ARGS ((RlcCb *gCb,
+PRIVATE Void rlcUmmCreatePdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *pdu,
U8 fi,
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmQSdu
+Void rlcUmmQSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *mBuf
)
#else
-PUBLIC Void kwUmmQSdu(gCb,rbCb,datReq,mBuf)
+Void rlcUmmQSdu(gCb,rbCb,datReq,mBuf)
RlcCb *gCb;
RlcDlRbCb *rbCb;
KwuDatReqInfo *datReq;
#endif
{
MsgLen len; /* SDU buffer length */
- KwSdu *sdu; /* SDU */
+ RlcSdu *sdu; /* SDU */
- TRC2(kwUmmQSdu)
+ TRC2(rlcUmmQSdu)
- KW_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
+ RLC_UPD_L2_DL_TOT_SDU_STS(gCb,rbCb);
- RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(KwSdu));
+ RLC_ALLOC_WC(gCb, sdu, (Size)sizeof(RlcSdu));
#if (ERRCLASS & ERRCLS_ADD_RES)
if ( sdu == NULLP )
{
#endif /* ERRCLASS & ERRCLS_ADD_RES */
/* Discard new changes starts */
- kwUtlGetCurrTime(&sdu->arrTime);
+ rlcUtlGetCurrTime(&sdu->arrTime);
/* Discard new changes ends */
SFndLenMsg(mBuf,&len);
cmLListAdd2Tail(&(rbCb->m.umDl.sduQ), &sdu->lstEnt);
sdu->lstEnt.node = (PTR)sdu;
- kwUmmEstHdrSz(&rbCb->m.umDl);
+ rlcUmmEstHdrSz(&rbCb->m.umDl);
if(!rlcDlUtlIsReestInProgress(rbCb))
{
- kwUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0);
+ rlcUtlSndDStaRsp(gCb,rbCb,rbCb->m.umDl.bo,rbCb->m.umDl.estHdrSz,FALSE,0);
}
/* kw005.201 added support for L2 Measurement */
if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_ACT_UE) &&
(rbCb->ueCb->numActRb[rbCb->qci]++ == 0))
{
- rlcCb.kwL2Cb.numActUe[rbCb->qci]++;
+ rlcCb.rlcL2Cb.numActUe[rbCb->qci]++;
}
#endif
* -# RFAILED If allocation of Sdu fails
*/
#ifdef ANSI
-PUBLIC Void kwUmmProcessSdus
+Void rlcUmmProcessSdus
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-KwDatReq *datReq
+RlcDatReq *datReq
)
#else
-PUBLIC Void kwUmmProcessSdus(gCb, rbCb, datReq)
+Void rlcUmmProcessSdus(gCb, rbCb, datReq)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-KwDatReq *datReq;
+RlcDatReq *datReq;
#endif
{
CmLList *firstNode; /* First Node in SDU queue */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- KwContSduLst contSduLst; /*Contained sduLst */
+ RlcContSduLst contSduLst; /*Contained sduLst */
S32 dataVol = rbCb->m.umDl.bo;
U32* totMacGrant= &(datReq->totMacGrant);
- KwL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
+ RlcL2MeasDlIpTh *dlIpThPut = &rbCb->l2MeasIpThruput.dlIpTh;
U8 *sduIdx = &dlIpThPut->lastSduIdx;
Bool newIdx = FALSE;
S32 oldBo;
- KwlchInfo lchInfo = {0};
+ RlclchInfo lchInfo = {0};
U32 segSduCnt = 0;
#endif
Ticks curTime = 0;
S16 timeDiff = 0;
- KwSdu *sdu;
+ RlcSdu *sdu;
- TRC2(kwUmmProcessSdus)
+ TRC2(rlcUmmProcessSdus)
pdu = NULLP;
#endif
/* Discard new changes starts */
- kwUtlGetCurrTime(&curTime);
+ rlcUtlGetCurrTime(&curTime);
/* ccpu00143043 */
while ((pduSz > 0) && (rbCb->m.umDl.sduQ.count > 0) &&
- (rbCb->m.umDl.numLi < KW_MAX_DL_LI) && (pduInfo->numPdu < KW_MAX_PDU))
+ (rbCb->m.umDl.numLi < RLC_MAX_DL_LI) && (pduInfo->numPdu < RLC_MAX_PDU))
{
CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,firstNode);
- sdu = (KwSdu *)(firstNode->node);
+ sdu = (RlcSdu *)(firstNode->node);
if ((sdu->mode.um.isSegmented == FALSE) && (rbCb->discTmrInt > 0) &&
(rbCb->rlcId.rbType == CM_LTE_DRB))
{
- timeDiff = KW_TIME_DIFF(curTime,sdu->arrTime);
+ timeDiff = RLC_TIME_DIFF(curTime,sdu->arrTime);
if (timeDiff >= rbCb->discTmrInt)
{
#ifdef LTE_L2_MEAS
- KW_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb);
+ RLC_UPD_L2_DL_DISC_SDU_STS(gCb, rbCb);
#endif
rbCb->m.umDl.bo -= sdu->sduSz;
- KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
+ RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
continue;
}
}
#endif
if (!pdu)
{
- KW_RMV_MAC_HDR_SZ(pduSz);
+ RLC_RMV_MAC_HDR_SZ(pduSz);
/* account for the RLC header size */
pduSz -= rbCb->m.umDl.snLen;
}
}
- kwUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz);
+ rlcUtlCalcLiForSdu(gCb,rbCb->m.umDl.numLi,sdu->sduSz,&pduSz);
/* Exact fit scenario :
If the SDU size matches with the PDU size
pduSz = 0;
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb))
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime;
lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE;
#endif
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
if((rbCb->rbL2Cb.measOn & LKW_L2MEAS_DL_DELAY) ||
(rbCb->rbL2Cb.measOn & LKW_L2MEAS_UU_LOSS))
{
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.arvlTime[lchInfo.numSdus] = sdu->arrTime;
lchInfo.numSdus++;
}
}
#endif /* LTE_L2_MEAS */
- KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu); /* kw003.201 */
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
set pdu to NULL
else
place the msglen in li array and continue with the next SDU.
- -# If the number of PDUs is more than KW_MAX_PDU, return from
+ -# If the number of PDUs is more than RLC_MAX_PDU, return from
the function even if pduSize > 0.
*/
else if (sdu->sduSz < pduSz)
pduSz -= sdu->sduSz;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, TRUE);
#endif /* LTE_L2_MEAS */
- if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < KW_MAX_DL_LI)
+ if (sdu->sduSz < 2048 && rbCb->m.umDl.numLi < RLC_MAX_DL_LI)
{
rbCb->m.umDl.li[(rbCb->m.umDl.numLi)++] = sdu->sduSz;
}
else
{
- kwUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo);
+ rlcUmmCreatePdu(gCb, rbCb, pdu, fi, pduInfo);
pdu = NULLP;
- if ( pduInfo->numPdu == KW_MAX_PDU)
+ if ( pduInfo->numPdu == RLC_MAX_PDU)
{
/* Could not transmit what MAC asked for because the number
* of PDUs to be transmitted has reached maximum. */
}
}
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) )
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) )
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
/* ccpu00143043 */
- if ( lchInfo.numSdus < KW_L2MEAS_SDUIDX)
+ if ( lchInfo.numSdus < RLC_L2MEAS_SDUIDX)
{
lchInfo.sduInfo[lchInfo.numSdus].arvlTime = sdu->arrTime;
lchInfo.sduInfo[lchInfo.numSdus].isRetxPdu = FALSE;
}
}
#endif
- KW_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu);
+ RLC_RMV_SDU(gCb,&(rbCb->m.umDl.sduQ),sdu);
/* kw005.201 ccpu00117318, updating the statistics */
- kwUtlIncrementKwuStsSduTx(gCb->u.dlCb->kwuDlSap + rbCb->kwuSapId);
+ rlcUtlIncrementKwuStsSduTx(gCb->u.dlCb->rlcKwuDlSap + rbCb->k1wuSapId);
}
/* Segmentation scenario :
If size of SDU is greater than PDU size
SSegMsg(sdu->mBuf,pduSz,&remSdu);
#ifdef LTE_L2_MEAS
- if(KW_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
+ if(RLC_MEAS_IS_DL_IP_MEAS_ON_FOR_RB(gCb, rbCb))
{
if(sdu->mode.um.isSegmented)
{
}
else
{
- KW_GETSDUIDX(*sduIdx);
+ RLC_GETSDUIDX(*sduIdx);
newIdx = TRUE;
}
- kwUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
- kwUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
+ rlcUtlUpdateContainedSduLst(*sduIdx, &contSduLst);
+ rlcUtlUpdateOutStandingSduLst(dlIpThPut, *sduIdx, sdu->actSz,
sdu->mode.um.sduId, newIdx);
}
- if(KW_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
+ if(RLC_MEAS_IS_DL_UU_LOSS_MEAS_ON_FOR_RB(gCb,rbCb))
{
if(sdu->actSz == sdu->sduSz)
{
fi |= 1;
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS_RLC
- kwUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE);
+ rlcUtlUpdSduSnMap(rbCb, sdu, datReq, FALSE);
#endif /* LTE_L2_MEAS */
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
/* kw005.201 added support for L2 Measurement */
{
if(--(rbCb->ueCb->numActRb[rbCb->qci]) == 0)
{
- rlcCb.kwL2Cb.numActUe[rbCb->qci]--;
+ rlcCb.rlcL2Cb.numActUe[rbCb->qci]--;
}
}
#endif /* LTE_L2_MEAS */
#ifdef LTE_L2_MEAS
- kwUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
+ rlcUtlUpdateBurstSdus(gCb, rbCb, &contSduLst, dataVol, *totMacGrant);
/* Need to check into optimizing this code : TODO */
- if(KW_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0))
+ if(RLC_MEAS_IS_DL_ANY_MEAS_ON_FOR_RB(gCb,rbCb) && (lchInfo.numSdus != 0))
{
- KwL2MeasTb *l2MeasTb = kwUtlGetCurMeasTb(gCb, rbCb);
+ RlcL2MeasTb *l2MeasTb = rlcUtlGetCurMeasTb(gCb, rbCb);
/* ccpu00143043 */
/* Fix Klock warning */
if ((lchInfo.numSdus != 0) && (l2MeasTb != NULLP) &&
- (l2MeasTb->numLchInfo < KW_MAX_ACTV_DRB))
+ (l2MeasTb->numLchInfo < RLC_MAX_ACTV_DRB))
{
- cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(KwlchInfo));
+ cmMemcpy((U8 *) &l2MeasTb->lchInfo[l2MeasTb->numLchInfo], (U8 *) &lchInfo, sizeof(RlclchInfo));
l2MeasTb->numLchInfo++;
}
l2MeasTb->txSegSduCnt += segSduCnt;
*/
if (pduSz > 0 && pdu)
{
- if (pduInfo->numPdu != KW_MAX_PDU)
+ if (pduInfo->numPdu != RLC_MAX_PDU)
{
rbCb->m.umDl.numLi--;
- kwUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
+ rlcUmmCreatePdu(gCb,rbCb,pdu,fi,pduInfo);
pdu = NULLP;
}
else
}
}
- kwUmmEstHdrSz(&rbCb->m.umDl);
+ rlcUmmEstHdrSz(&rbCb->m.umDl);
datReq->boRep.bo = rbCb->m.umDl.bo;
datReq->boRep.estHdrSz = rbCb->m.umDl.estHdrSz;
datReq->boRep.staPduPrsnt = FALSE;
if (rbCb->m.umDl.sduQ.count > 0)
{
datReq->boRep.oldestSduArrTime =
- ((KwSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime;
+ ((RlcSdu *)(rbCb->m.umDl.sduQ.first->node))->arrTime;
}
RETVOID;
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void rlcDlUmmReEstablish
+Void rlcDlUmmReEstablish
(
RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void rlcDlUmmReEstablish(gCb, rlcId, rbCb)
+Void rlcDlUmmReEstablish(gCb, rlcId, rbCb)
RlcCb *gCb;
CmLteRlcId rlcId;
Bool sendReEst;
TRC2(rlcDlUmmReEstablish)
- kwUmmFreeDlRbCb(gCb, rbCb);
+ rlcUmmFreeDlRbCb(gCb, rbCb);
rbCb->m.umDl.vtUs = 0;
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmCreatePdu
+PRIVATE Void rlcUmmCreatePdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
KwPduInfo *datReqPduInfo
)
#else
-PRIVATE Void kwUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo)
+PRIVATE Void rlcUmmCreatePdu(gCb, rbCb, pdu, fi, datReqPduInfo)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *pdu;
KwPduInfo *datReqPduInfo
#endif
{
- KwSn sn; /* Sequence Number */
+ RlcSn sn; /* Sequence Number */
U32 liCount; /* LI count */
U8 e = 0; /* Extension Bit */
U32 count; /* Loop Counter */
* size of header = ( NumLi /2 ) * 3 + (NumLi % 2) * 2 + 2;
* where NumLi = Number of Length Indicators to be sent
*/
- U8 hdr[((KW_MAX_DL_LI >> 1) * 3) + ((KW_MAX_DL_LI & 0x01) << 1) + 2];
+ U8 hdr[((RLC_MAX_DL_LI >> 1) * 3) + ((RLC_MAX_DL_LI & 0x01) << 1) + 2];
U32 idx = 0; /* To index to the hdr array */
/* Note: idx is not checked against crossing the hdr array bound as
- * liCount will be < KW_MAX_DL_LI and as per the size calculated above;
+ * liCount will be < RLC_MAX_DL_LI and as per the size calculated above;
* idx cannot cross the array
*/
- TRC2(kwUmmCreatePdu)
+ TRC2(rlcUmmCreatePdu)
/* stats updated before for bytes sent before adding RLC headers */
- kwUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu);
+ rlcUtlIncrementGenStsBytesAndPdusSent(&gCb->genSts, pdu);
sn = rbCb->m.umDl.vtUs;
liCount = rbCb->m.umDl.numLi;
- if(liCount > KW_MAX_DL_LI)
- liCount = KW_MAX_DL_LI;
+ if(liCount > RLC_MAX_DL_LI)
+ liCount = RLC_MAX_DL_LI;
/* if there are any LI's then set the first E bit */
if(liCount)
* @return Void
*/
#ifdef ANSI
-PRIVATE Void kwUmmEstHdrSz
+PRIVATE Void rlcUmmEstHdrSz
(
-KwUmDl *umDl
+RlcUmDl *umDl
)
#else
-PRIVATE Void kwUmmEstHdrSz(umDl)
-KwUmDl *umDl;
+PRIVATE Void rlcUmmEstHdrSz(umDl)
+RlcUmDl *umDl;
#endif
{
/* The header size is estimated as :
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmDiscSdu
+Void rlcUmmDiscSdu
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
U32 sduId
)
#else
-PUBLIC Void kwUmmDiscSdu(gCb,rbCb,sduId)
+Void rlcUmmDiscSdu(gCb,rbCb,sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
U32 sduId;
{
CmLList *tmpNode; /* Temporary Node in SDU queue */
- TRC2(kwUmmDiscSdu)
+ TRC2(rlcUmmDiscSdu)
CM_LLIST_FIRST_NODE(&rbCb->m.umDl.sduQ,tmpNode);
if (tmpNode)
{
- KwSdu *sdu = (KwSdu *)tmpNode->node;
+ RlcSdu *sdu = (RlcSdu *)tmpNode->node;
if (sdu->mode.um.sduId == sduId && sdu->mode.um.isSegmented == FALSE)
{
/* kw005.201 added support for L2 Measurement */
- KW_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
+ RLC_RMV_SDU(gCb,&rbCb->m.umDl.sduQ,sdu);
gCb->genSts.numSduDisc++;
}
}
* @return Void
*/
#ifdef ANSI
-PUBLIC Void kwUmmFreeDlRbCb
+Void rlcUmmFreeDlRbCb
(
RlcCb *gCb,
RlcDlRbCb *rbCb
)
#else
-PUBLIC Void kwUmmFreeDlRbCb(gCb,rbCb)
+Void rlcUmmFreeDlRbCb(gCb,rbCb)
RlcCb *gCb;
RlcDlRbCb *rbCb;
#endif
{
- TRC2(kwUmmFreeDlRbCb)
+ TRC2(rlcUmmFreeDlRbCb)
/* cat the SDU queue to the to be freed list */
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ));
- kwUtlRaiseDlCleanupEvent(gCb);
+ rlcUtlRaiseDlCleanupEvent(gCb);
RETVOID;
-} /* kwUmmFreeDlRbCb */
+} /* rlcUmmFreeDlRbCb */
/********************************************************************30**
End of file
Code Review / o-du / l2.git / blobdiff