[tarantool-patches] [PATCH v1 06/28] sql: disable lookaside system

[imeevma@tarantool.org]

Since the lookaside system is not currently in use, it must be
completely disabled.
---
 src/box/sql/main.c      |  76 ------------------------------
 src/box/sql/malloc.c    | 123 ++++--------------------------------------------
 src/box/sql/printf.c    |   2 +-
 src/box/sql/sqlInt.h    |  44 +----------------
 src/box/sql/vdbeaux.c   |   2 +-
 src/box/sql/vdbemem.c   |   9 ++--
 src/box/sql/whereexpr.c |   3 +-
 7 files changed, 17 insertions(+), 242 deletions(-)

diff --git a/src/box/sql/main.c b/src/box/sql/main.c
index 450f7d1..29a7911 100644
--- a/src/box/sql/main.c
+++ b/src/box/sql/main.c
@@ -173,78 +173,6 @@ sql_initialize(void)
 	return rc;
 }
 
-/*
- * Set up the lookaside buffers for a database connection.
- * Return SQL_OK on success.
- * If lookaside is already active, return SQL_BUSY.
- *
- * The sz parameter is the number of bytes in each lookaside slot.
- * The cnt parameter is the number of slots.  If pStart is NULL the
- * space for the lookaside memory is obtained from sql_malloc().
- * If pStart is not NULL then it is sz*cnt bytes of memory to use for
- * the lookaside memory.
- */
-static int
-setupLookaside(sql * db, void *pBuf, int sz, int cnt)
-{
-#ifndef SQL_OMIT_LOOKASIDE
-	void *pStart;
-	if (db->lookaside.nOut) {
-		return SQL_BUSY;
-	}
-	/* Free any existing lookaside buffer for this handle before
-	 * allocating a new one so we don't have to have space for
-	 * both at the same time.
-	 */
-	if (db->lookaside.bMalloced) {
-		sql_free(db->lookaside.pStart);
-	}
-	/* The size of a lookaside slot after ROUNDDOWN8 needs to be larger
-	 * than a pointer to be useful.
-	 */
-	sz = ROUNDDOWN8(sz);	/* IMP: R-33038-09382 */
-	if (sz <= (int)sizeof(LookasideSlot *))
-		sz = 0;
-	if (cnt < 0)
-		cnt = 0;
-	if (sz == 0 || cnt == 0) {
-		sz = 0;
-		pStart = 0;
-	} else if (pBuf == 0) {
-		sqlBeginBenignMalloc();
-		pStart = sqlMalloc(sz * cnt);	/* IMP: R-61949-35727 */
-		sqlEndBenignMalloc();
-		if (pStart)
-			cnt = sqlMallocSize(pStart) / sz;
-	} else {
-		pStart = pBuf;
-	}
-	db->lookaside.pStart = pStart;
-	db->lookaside.pFree = 0;
-	db->lookaside.sz = (u16) sz;
-	if (pStart) {
-		int i;
-		LookasideSlot *p;
-		assert(sz > (int)sizeof(LookasideSlot *));
-		p = (LookasideSlot *) pStart;
-		for (i = cnt - 1; i >= 0; i--) {
-			p->pNext = db->lookaside.pFree;
-			db->lookaside.pFree = p;
-			p = (LookasideSlot *) & ((u8 *) p)[sz];
-		}
-		db->lookaside.pEnd = p;
-		db->lookaside.bDisable = 0;
-		db->lookaside.bMalloced = pBuf == 0 ? 1 : 0;
-	} else {
-		db->lookaside.pStart = db;
-		db->lookaside.pEnd = db;
-		db->lookaside.bDisable = 1;
-		db->lookaside.bMalloced = 0;
-	}
-#endif				/* SQL_OMIT_LOOKASIDE */
-	return SQL_OK;
-}
-
 void
 sql_row_count(struct sql_context *context, MAYBE_UNUSED int unused1,
 	      MAYBE_UNUSED sql_value **unused2)
@@ -630,10 +558,6 @@ sql_init_db(sql **out_db)
 	 */
 	sqlRegisterPerConnectionBuiltinFunctions(db);
 
-	/* Enable the lookaside-malloc subsystem */
-	setupLookaside(db, 0, sqlGlobalConfig.szLookaside,
-		       sqlGlobalConfig.nLookaside);
-
 opendb_out:
 	assert(db != 0 || rc == SQL_NOMEM);
 	if (rc == SQL_NOMEM)
diff --git a/src/box/sql/malloc.c b/src/box/sql/malloc.c
index 925ffb2..a7549db 100644
--- a/src/box/sql/malloc.c
+++ b/src/box/sql/malloc.c
@@ -412,7 +412,6 @@ sqlScratchMalloc(int n)
 			sqlStatusUp(SQL_STATUS_SCRATCH_OVERFLOW,
 					sqlMallocSize(p));
 		}
-		sqlMemdebugSetType(p, MEMTYPE_SCRATCH);
 	}
 
 #if !defined(NDEBUG)
@@ -457,10 +456,6 @@ sqlScratchFree(void *p)
 			sqlStatusDown(SQL_STATUS_SCRATCH_USED, 1);
 		} else {
 			/* Release memory back to the heap */
-			assert(sqlMemdebugHasType(p, MEMTYPE_SCRATCH));
-			assert(sqlMemdebugNoType
-			       (p, (u8) ~ MEMTYPE_SCRATCH));
-			sqlMemdebugSetType(p, MEMTYPE_HEAP);
 			if (sqlGlobalConfig.bMemstat) {
 				int iSize = sqlMallocSize(p);
 				sqlStatusDown
@@ -477,55 +472,25 @@ sqlScratchFree(void *p)
 }
 
 /*
- * TRUE if p is a lookaside memory allocation from db
- */
-#ifndef SQL_OMIT_LOOKASIDE
-static int
-isLookaside(sql * db, void *p)
-{
-	return SQL_WITHIN(p, db->lookaside.pStart, db->lookaside.pEnd);
-}
-#else
-#define isLookaside(A,B) 0
-#endif
-
-/*
  * Return the size of a memory allocation previously obtained from
  * sqlMalloc() or sql_malloc().
  */
 int
 sqlMallocSize(void *p)
 {
-	assert(sqlMemdebugHasType(p, MEMTYPE_HEAP));
 	return sql_sized_sizeof(p);
 }
 
 int
-sqlDbMallocSize(sql * db, void *p)
+sqlDbMallocSize(void *p)
 {
 	assert(p != 0);
-	if (db == 0 || !isLookaside(db, p)) {
-#if SQL_DEBUG
-		if (db == 0) {
-			assert(sqlMemdebugNoType(p, (u8) ~ MEMTYPE_HEAP));
-			assert(sqlMemdebugHasType(p, MEMTYPE_HEAP));
-		} else {
-			assert(sqlMemdebugHasType
-			       (p, (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-			assert(sqlMemdebugNoType
-			       (p, (u8) ~ (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-		}
-#endif
-		return sql_sized_sizeof(p);
-	} else
-		return db->lookaside.sz;
+	return sql_sized_sizeof(p);
 }
 
 sql_uint64
 sql_msize(void *p)
 {
-	assert(sqlMemdebugNoType(p, (u8) ~ MEMTYPE_HEAP));
-	assert(sqlMemdebugHasType(p, MEMTYPE_HEAP));
 	return p ? sql_sized_sizeof(p) : 0;
 }
 
@@ -537,8 +502,6 @@ sql_free(void *p)
 {
 	if (p == 0)
 		return;		/* IMP: R-49053-54554 */
-	assert(sqlMemdebugHasType(p, MEMTYPE_HEAP));
-	assert(sqlMemdebugNoType(p, (u8) ~ MEMTYPE_HEAP));
 	if (sqlGlobalConfig.bMemstat) {
 		sqlStatusDown(SQL_STATUS_MEMORY_USED,
 				  sqlMallocSize(p));
@@ -555,7 +518,7 @@ sql_free(void *p)
 static SQL_NOINLINE void
 measureAllocationSize(sql * db, void *p)
 {
-	*db->pnBytesFreed += sqlDbMallocSize(db, p);
+	*db->pnBytesFreed += sqlDbMallocSize(p);
 }
 
 /*
@@ -572,23 +535,7 @@ sqlDbFree(sql * db, void *p)
 			measureAllocationSize(db, p);
 			return;
 		}
-		if (isLookaside(db, p)) {
-			LookasideSlot *pBuf = (LookasideSlot *) p;
-#if SQL_DEBUG
-			/* Trash all content in the buffer being freed */
-			memset(p, 0xaa, db->lookaside.sz);
-#endif
-			pBuf->pNext = db->lookaside.pFree;
-			db->lookaside.pFree = pBuf;
-			db->lookaside.nOut--;
-			return;
-		}
 	}
-	assert(sqlMemdebugHasType(p, (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-	assert(sqlMemdebugNoType
-	       (p, (u8) ~ (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-	assert(db != 0 || sqlMemdebugNoType(p, MEMTYPE_LOOKASIDE));
-	sqlMemdebugSetType(p, MEMTYPE_HEAP);
 	sql_free(p);
 }
 
@@ -600,8 +547,6 @@ sqlRealloc(void *pOld, u64 nBytes)
 {
 	int nOld, nNew, nDiff;
 	void *pNew;
-	assert(sqlMemdebugHasType(pOld, MEMTYPE_HEAP));
-	assert(sqlMemdebugNoType(pOld, (u8) ~ MEMTYPE_HEAP));
 	if (pOld == 0) {
 		return sqlMalloc(nBytes);	/* IMP: R-04300-56712 */
 	}
@@ -698,9 +643,6 @@ dbMallocRawFinish(sql * db, u64 n)
 	p = sqlMalloc(n);
 	if (!p)
 		sqlOomFault(db);
-	sqlMemdebugSetType(p,
-			       (db->lookaside.bDisable ==
-				0) ? MEMTYPE_LOOKASIDE : MEMTYPE_HEAP);
 	return p;
 }
 
@@ -733,42 +675,15 @@ sqlDbMallocRaw(sql * db, u64 n)
 	if (db)
 		return sqlDbMallocRawNN(db, n);
 	p = sqlMalloc(n);
-	sqlMemdebugSetType(p, MEMTYPE_HEAP);
 	return p;
 }
 
 void *
 sqlDbMallocRawNN(sql * db, u64 n)
 {
-#ifndef SQL_OMIT_LOOKASIDE
-	LookasideSlot *pBuf;
-	assert(db != 0);
-	assert(db->pnBytesFreed == 0);
-	if (db->lookaside.bDisable == 0) {
-		assert(db->mallocFailed == 0);
-		if (n > db->lookaside.sz) {
-			db->lookaside.anStat[1]++;
-		} else if ((pBuf = db->lookaside.pFree) == 0) {
-			db->lookaside.anStat[2]++;
-		} else {
-			db->lookaside.pFree = pBuf->pNext;
-			db->lookaside.nOut++;
-			db->lookaside.anStat[0]++;
-			if (db->lookaside.nOut > db->lookaside.mxOut) {
-				db->lookaside.mxOut = db->lookaside.nOut;
-			}
-			return (void *)pBuf;
-		}
-	} else if (db->mallocFailed) {
-		return 0;
-	}
-#else
-	assert(db != 0);
-	assert(db->pnBytesFreed == 0);
-	if (db->mallocFailed) {
-		return 0;
-	}
-#endif
+	assert(db != NULL && db->pnBytesFreed == NULL);
+	if (db->mallocFailed)
+		return NULL;
 	return dbMallocRawFinish(db, n);
 }
 
@@ -785,8 +700,6 @@ sqlDbRealloc(sql * db, void *p, u64 n)
 	assert(db != 0);
 	if (p == 0)
 		return sqlDbMallocRawNN(db, n);
-	if (isLookaside(db, p) && n <= db->lookaside.sz)
-		return p;
 	return dbReallocFinish(db, p, n);
 }
 
@@ -797,27 +710,9 @@ dbReallocFinish(sql * db, void *p, u64 n)
 	assert(db != 0);
 	assert(p != 0);
 	if (db->mallocFailed == 0) {
-		if (isLookaside(db, p)) {
-			pNew = sqlDbMallocRawNN(db, n);
-			if (pNew) {
-				memcpy(pNew, p, db->lookaside.sz);
-				sqlDbFree(db, p);
-			}
-		} else {
-			assert(sqlMemdebugHasType
-			       (p, (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-			assert(sqlMemdebugNoType
-			       (p, (u8) ~ (MEMTYPE_LOOKASIDE | MEMTYPE_HEAP)));
-			sqlMemdebugSetType(p, MEMTYPE_HEAP);
-			pNew = sql_realloc64(p, n);
-			if (!pNew) {
-				sqlOomFault(db);
-			}
-			sqlMemdebugSetType(pNew,
-					       (db->lookaside.bDisable ==
-						0 ? MEMTYPE_LOOKASIDE :
-						MEMTYPE_HEAP));
-		}
+		pNew = sql_realloc64(p, n);
+		if (!pNew)
+			sqlOomFault(db);
 	}
 	return pNew;
 }
diff --git a/src/box/sql/printf.c b/src/box/sql/printf.c
index 31d21db..c364055 100644
--- a/src/box/sql/printf.c
+++ b/src/box/sql/printf.c
@@ -874,7 +874,7 @@ sqlStrAccumEnlarge(StrAccum * p, int N)
 			if (!isMalloced(p) && p->nChar > 0)
 				memcpy(zNew, p->zText, p->nChar);
 			p->zText = zNew;
-			p->nAlloc = sqlDbMallocSize(p->db, zNew);
+			p->nAlloc = sqlDbMallocSize(zNew);
 			p->printfFlags |= SQL_PRINTF_MALLOCED;
 		} else {
 			sqlStrAccumReset(p);
diff --git a/src/box/sql/sqlInt.h b/src/box/sql/sqlInt.h
index 7c00990..d2e429e 100644
--- a/src/box/sql/sqlInt.h
+++ b/src/box/sql/sqlInt.h
@@ -3021,7 +3021,7 @@ void *sqlDbReallocOrFree(sql *, void *, u64);
 void *sqlDbRealloc(sql *, void *, u64);
 void sqlDbFree(sql *, void *);
 int sqlMallocSize(void *);
-int sqlDbMallocSize(sql *, void *);
+int sqlDbMallocSize(void *);
 void *sqlScratchMalloc(int);
 void sqlScratchFree(void *);
 void *sqlPageMalloc(int);
@@ -4946,48 +4946,6 @@ void sqlVdbeIOTraceSql(Vdbe *);
 #endif
 
 /*
- * These routines are available for the mem2.c debugging memory allocator
- * only.  They are used to verify that different "types" of memory
- * allocations are properly tracked by the system.
- *
- * sqlMemdebugSetType() sets the "type" of an allocation to one of
- * the MEMTYPE_* macros defined below.  The type must be a bitmask with
- * a single bit set.
- *
- * sqlMemdebugHasType() returns true if any of the bits in its second
- * argument match the type set by the previous sqlMemdebugSetType().
- * sqlMemdebugHasType() is intended for use inside assert() statements.
- *
- * sqlMemdebugNoType() returns true if none of the bits in its second
- * argument match the type set by the previous sqlMemdebugSetType().
- *
- * Perhaps the most important point is the difference between MEMTYPE_HEAP
- * and MEMTYPE_LOOKASIDE.  If an allocation is MEMTYPE_LOOKASIDE, that means
- * it might have been allocated by lookaside, except the allocation was
- * too large or lookaside was already full.  It is important to verify
- * that allocations that might have been satisfied by lookaside are not
- * passed back to non-lookaside free() routines.  Asserts such as the
- * example above are placed on the non-lookaside free() routines to verify
- * this constraint.
- *
- * All of this is no-op for a production build.  It only comes into
- * play when the sql_MEMDEBUG compile-time option is used.
- */
-#ifdef SQL_MEMDEBUG
-void sqlMemdebugSetType(void *, u8);
-int sqlMemdebugHasType(void *, u8);
-int sqlMemdebugNoType(void *, u8);
-#else
-#define sqlMemdebugSetType(X,Y)	/* no-op */
-#define sqlMemdebugHasType(X,Y)  1
-#define sqlMemdebugNoType(X,Y)   1
-#endif
-#define MEMTYPE_HEAP       0x01	/* General heap allocations */
-#define MEMTYPE_LOOKASIDE  0x02	/* Heap that might have been lookaside */
-#define MEMTYPE_SCRATCH    0x04	/* Scratch allocations */
-#define MEMTYPE_PCACHE     0x08	/* Page cache allocations */
-
-/*
  * Threading interface
  */
 #if SQL_MAX_WORKER_THREADS>0
diff --git a/src/box/sql/vdbeaux.c b/src/box/sql/vdbeaux.c
index 697dffd..fbe5338 100644
--- a/src/box/sql/vdbeaux.c
+++ b/src/box/sql/vdbeaux.c
@@ -192,7 +192,7 @@ growOpArray(Vdbe * v, int nOp)
 	assert(nNew >= (p->nOpAlloc + nOp));
 	pNew = sqlDbRealloc(p->db, v->aOp, nNew * sizeof(Op));
 	if (pNew) {
-		p->szOpAlloc = sqlDbMallocSize(p->db, pNew);
+		p->szOpAlloc = sqlDbMallocSize(pNew);
 		p->nOpAlloc = p->szOpAlloc / sizeof(Op);
 		v->aOp = pNew;
 	}
diff --git a/src/box/sql/vdbemem.c b/src/box/sql/vdbemem.c
index 248f80b..2bb9bd3 100644
--- a/src/box/sql/vdbemem.c
+++ b/src/box/sql/vdbemem.c
@@ -70,7 +70,7 @@ sqlVdbeCheckMemInvariants(Mem * p)
 
 	/* The szMalloc field holds the correct memory allocation size */
 	assert(p->szMalloc == 0
-	       || p->szMalloc == sqlDbMallocSize(p->db, p->zMalloc));
+	       || p->szMalloc == sqlDbMallocSize(p->zMalloc));
 
 	/* If p holds a string or blob, the Mem.z must point to exactly
 	 * one of the following:
@@ -112,8 +112,7 @@ sqlVdbeMemGrow(Mem * pMem, int n, int bPreserve)
 	testcase(bPreserve && pMem->z == 0);
 
 	assert(pMem->szMalloc == 0
-	       || pMem->szMalloc == sqlDbMallocSize(pMem->db,
-							pMem->zMalloc));
+	       || pMem->szMalloc == sqlDbMallocSize(pMem->zMalloc));
 	if (pMem->szMalloc < n) {
 		if (n < 32)
 			n = 32;
@@ -133,7 +132,7 @@ sqlVdbeMemGrow(Mem * pMem, int n, int bPreserve)
 			return SQL_NOMEM;
 		} else {
 			pMem->szMalloc =
-			    sqlDbMallocSize(pMem->db, pMem->zMalloc);
+			    sqlDbMallocSize(pMem->zMalloc);
 		}
 	}
 
@@ -1007,7 +1006,7 @@ sqlVdbeMemSetStr(Mem * pMem,	/* Memory cell to set to string value */
 	} else if (xDel == SQL_DYNAMIC) {
 		sqlVdbeMemRelease(pMem);
 		pMem->zMalloc = pMem->z = (char *)z;
-		pMem->szMalloc = sqlDbMallocSize(pMem->db, pMem->zMalloc);
+		pMem->szMalloc = sqlDbMallocSize(pMem->zMalloc);
 	} else {
 		sqlVdbeMemRelease(pMem);
 		pMem->z = (char *)z;
diff --git a/src/box/sql/whereexpr.c b/src/box/sql/whereexpr.c
index 30017b0..a954b17 100644
--- a/src/box/sql/whereexpr.c
+++ b/src/box/sql/whereexpr.c
@@ -107,8 +107,7 @@ whereClauseInsert(WhereClause * pWC, Expr * p, u16 wtFlags)
 		if (pOld != pWC->aStatic) {
 			sqlDbFree(db, pOld);
 		}
-		pWC->nSlot =
-		    sqlDbMallocSize(db, pWC->a) / sizeof(pWC->a[0]);
+		pWC->nSlot = sqlDbMallocSize(pWC->a) / sizeof(pWC->a[0]);
 	}
 	pTerm = &pWC->a[idx = pWC->nTerm++];
 	if (p && ExprHasProperty(p, EP_Unlikely)) {
-- 
2.7.4