Skip to content

M
mariadb
Commit 8b40a79c authored by marko's avatar marko
Browse files
Options

branches/zip: Enable calls to inlined InnoDB functions in ha_innodb.cc, 

now that all of InnoDB code is built from a single Makefile and it should
not be possible to build the modules with mutually incompatible options.

#define INSIDE_HA_INNOBASE_CC: Remove.

srv_sizeof_trx_t_in_ha_innodb_cc: Remove.

dict_table_get_low_noninlined(): Remove.  This function was unused.

Remove all _noninline functions.  Remove the _noninline suffix from
all function calls in ha_innodb.cc.
parent 7e687905
Expand all Show whitespace changes
Inline Side-by-side
Showing with 58 additions and 616 deletions
data/data0data.c
View file @ 8b40a79c
......@@ -29,41 +29,6 @@ ulint data_dummy; /* this is used to fool the compiler in
dtuple_validate */
#endif /* UNIV_DEBUG */
/* Some non-inlined functions used in the MySQL interface: */
void
dfield_set_data_noninline(
dfield_t* field, /* in: field */
void* data, /* in: data */
ulint len) /* in: length or UNIV_SQL_NULL */
{
dfield_set_data(field, data, len);
}
void*
dfield_get_data_noninline(
dfield_t* field) /* in: field */
{
return(dfield_get_data(field));
}
ulint
dfield_get_len_noninline(
const dfield_t* field) /* in: field */
{
return(dfield_get_len(field));
}
ulint
dtuple_get_n_fields_noninline(
const dtuple_t* tuple) /* in: tuple */
{
return(dtuple_get_n_fields(tuple));
}
const dfield_t*
dtuple_get_nth_field_noninline(
const dtuple_t* tuple, /* in: tuple */
ulint n) /* in: index of field */
{
return(dtuple_get_nth_field(tuple, n));
}
/*************************************************************************
Tests if dfield data length and content is equal to the given. */
......
data/data0type.c
View file @ 8b40a79c
......@@ -152,17 +152,6 @@ dtype_is_non_binary_string_type(
return(FALSE);
}
/*************************************************************************
Gets the MySQL charset-collation code for MySQL string types. */
ulint
dtype_get_charset_coll_noninline(
/*=============================*/
ulint prtype) /* in: precise data type */
{
return(dtype_get_charset_coll(prtype));
}
/*************************************************************************
Forms a precise type from the < 4.1.2 format precise type plus the
charset-collation code. */
......
dict/dict0dict.c
View file @ 8b40a79c
......@@ -320,55 +320,6 @@ dict_table_decrement_handle_count(
mutex_exit(&(dict_sys->mutex));
}
/*************************************************************************
Gets the column data type. */
void
dict_col_copy_type_noninline(
/*=========================*/
const dict_col_t* col, /* in: column */
dtype_t* type) /* out: data type */
{
dict_col_copy_type(col, type);
}
/************************************************************************
Gets the nth column of a table. */
const dict_col_t*
dict_table_get_nth_col_noninline(
/*=============================*/
/* out: pointer to column object */
const dict_table_t* table, /* in: table */
ulint pos) /* in: position of column */
{
return(dict_table_get_nth_col(table, pos));
}
/************************************************************************
Gets the first index on the table (the clustered index). */
dict_index_t*
dict_table_get_first_index_noninline(
/*=================================*/
/* out: index, NULL if none exists */
dict_table_t* table) /* in: table */
{
return(dict_table_get_first_index(table));
}
/************************************************************************
Gets the next index on the table. */
dict_index_t*
dict_table_get_next_index_noninline(
/*================================*/
/* out: index, NULL if none left */
dict_index_t* index) /* in: index */
{
return(dict_table_get_next_index(index));
}
/**************************************************************************
Returns a column's name. */
......@@ -730,19 +681,6 @@ dict_table_get_nth_col_pos(
n));
}
/************************************************************************
Check whether the table uses the compact page format. */
ibool
dict_table_is_comp_noninline(
/*=========================*/
/* out: TRUE if table uses the
compact page format */
const dict_table_t* table) /* in: table */
{
return(dict_table_is_comp(table));
}
/************************************************************************
Checks if a column is in the ordering columns of the clustered index of a
table. Column prefixes are treated like whole columns. */
......@@ -1310,18 +1248,6 @@ dict_table_remove_from_cache(
dict_mem_table_free(table);
}
/*************************************************************************
Gets the column position in the clustered index. */
ulint
dict_col_get_clust_pos_noninline(
/*=============================*/
const dict_col_t* col, /* in: table column */
const dict_index_t* clust_index) /* in: clustered index */
{
return(dict_col_get_clust_pos(col, clust_index));
}
/********************************************************************
If the given column name is reserved for InnoDB system columns, return
TRUE. */
......@@ -4003,18 +3929,6 @@ dict_update_statistics(
dict_update_statistics_low(table, FALSE);
}
/**************************************************************************
A noninlined version of dict_table_get_low. */
dict_table_t*
dict_table_get_low_noninlined(
/*==========================*/
/* out: table, NULL if not found */
const char* table_name) /* in: table name */
{
return(dict_table_get_low(table_name));
}
/**************************************************************************
Prints info of a foreign key constraint. */
static
......
handler/ha_innodb.cc
View file @ 8b40a79c
This diff is collapsed.
include/data0data.h
View file @ 8b40a79c
......@@ -18,26 +18,6 @@ Created 5/30/1994 Heikki Tuuri
typedef struct big_rec_struct big_rec_t;
/* Some non-inlined functions used in the MySQL interface: */
void
dfield_set_data_noninline(
dfield_t* field, /* in: field */
void* data, /* in: data */
ulint len); /* in: length or UNIV_SQL_NULL */
void*
dfield_get_data_noninline(
dfield_t* field); /* in: field */
ulint
dfield_get_len_noninline(
const dfield_t* field); /* in: field */
ulint
dtuple_get_n_fields_noninline(
const dtuple_t* tuple); /* in: tuple */
const dfield_t*
dtuple_get_nth_field_noninline(
const dtuple_t* tuple, /* in: tuple */
ulint n); /* in: index of field */
#ifdef UNIV_DEBUG
/*************************************************************************
Gets pointer to the type struct of SQL data field. */
......
include/data0type.h
View file @ 8b40a79c
......@@ -257,13 +257,6 @@ dtype_get_mblen(
multi-byte character */
/*************************************************************************
Gets the MySQL charset-collation code for MySQL string types. */
ulint
dtype_get_charset_coll_noninline(
/*=============================*/
ulint prtype);/* in: precise data type */
/*************************************************************************
Gets the MySQL charset-collation code for MySQL string types. */
UNIV_INLINE
ulint
dtype_get_charset_coll(
......
include/dict0dict.h
View file @ 8b40a79c
......@@ -93,14 +93,6 @@ dict_col_copy_type(
/*===============*/
const dict_col_t* col, /* in: column */
dtype_t* type); /* out: data type */
/*************************************************************************
Gets the column data type. */
void
dict_col_copy_type_noninline(
/*=========================*/
const dict_col_t* col, /* in: column */
dtype_t* type); /* out: data type */
#ifdef UNIV_DEBUG
/*************************************************************************
Assert that a column and a data type match. */
......@@ -162,14 +154,6 @@ dict_col_get_clust_pos(
/*===================*/
const dict_col_t* col, /* in: table column */
const dict_index_t* clust_index); /* in: clustered index */
/*************************************************************************
Gets the column position in the clustered index. */
ulint
dict_col_get_clust_pos_noninline(
/*=============================*/
const dict_col_t* col, /* in: table column */
const dict_index_t* clust_index); /* in: clustered index */
/********************************************************************
If the given column name is reserved for InnoDB system columns, return
TRUE. */
......@@ -446,14 +430,6 @@ dict_table_get_on_id_low(
/* out: table, NULL if does not exist */
dulint table_id); /* in: table id */
/**************************************************************************
A noninlined version of dict_table_get_low. */
dict_table_t*
dict_table_get_low_noninlined(
/*==========================*/
/* out: table, NULL if not found */
const char* table_name); /* in: table name */
/**************************************************************************
Returns an index object by matching on the name and column names and if
more than index is found return the index with the higher id.*/
......@@ -539,14 +515,6 @@ dict_table_get_first_index(
/* out: index, NULL if none exists */
dict_table_t* table); /* in: table */
/************************************************************************
Gets the first index on the table (the clustered index). */
dict_index_t*
dict_table_get_first_index_noninline(
/*=================================*/
/* out: index, NULL if none exists */
dict_table_t* table); /* in: table */
/************************************************************************
Gets the next index on the table. */
UNIV_INLINE
dict_index_t*
......@@ -555,15 +523,6 @@ dict_table_get_next_index(
/* out: index, NULL if none left */
dict_index_t* index); /* in: index */
/************************************************************************
Gets the next index on the table. */
dict_index_t*
dict_table_get_next_index_noninline(
/*================================*/
/* out: index, NULL if none left */
dict_index_t* index); /* in: index */
/************************************************************************
Check whether the index is the clustered index. */
UNIV_INLINE
ulint
......@@ -638,15 +597,6 @@ dict_table_get_sys_col(
((table)->cols + (table)->n_cols + (sys) - DATA_N_SYS_COLS)
#endif /* UNIV_DEBUG */
/************************************************************************
Gets the nth column of a table. */
const dict_col_t*
dict_table_get_nth_col_noninline(
/*=============================*/
/* out: pointer to column object */
const dict_table_t* table, /* in: table */
ulint pos); /* in: position of column */
/************************************************************************
Gets the given system column number of a table. */
UNIV_INLINE
ulint
......@@ -673,15 +623,6 @@ dict_table_is_comp(
compact page format */
const dict_table_t* table); /* in: table */
/************************************************************************
Check whether the table uses the compact page format. */
ibool
dict_table_is_comp_noninline(
/*=========================*/
/* out: TRUE if table uses the
compact page format */
const dict_table_t* table); /* in: table */
/************************************************************************
Check whether the table uses the compressed compact page format. */
UNIV_INLINE
ulint
......@@ -1121,15 +1062,6 @@ dict_table_find_equivalent_index(
dict_table_t* table, /* in/out: table */
dict_index_t* index); /* in: index to match */
/**************************************************************************
Find and return an index in the table that matches the index id.*/
dict_index_t*
dict_table_get_index_on_id_noninline(
/*=================================*/
/* out: index, NULL if does not exist */
dict_table_t* table, /* in: table */
dulint index_id);/* in: table id */
/**************************************************************************
In case there is more than one index with the same name return the index
with the min(id). */
......
include/mem0mem.h
View file @ 8b40a79c
......@@ -73,12 +73,6 @@ heap creation. */
Use this macro instead of the corresponding function! Macro for memory
heap creation. */
#define mem_heap_create_noninline(N) mem_heap_create_func_noninline(\
(N), MEM_HEAP_DYNAMIC, __FILE__, __LINE__)
/******************************************************************
Use this macro instead of the corresponding function! Macro for memory
heap creation. */
#define mem_heap_create_in_buffer(N) mem_heap_create_func(\
(N), MEM_HEAP_BUFFER, __FILE__, __LINE__)
/******************************************************************
......@@ -95,12 +89,6 @@ heap freeing. */
#define mem_heap_free(heap) mem_heap_free_func(\
(heap), __FILE__, __LINE__)
/******************************************************************
Use this macro instead of the corresponding function! Macro for memory
heap freeing. */
#define mem_heap_free_noninline(heap) mem_heap_free_func_noninline(\
(heap), __FILE__, __LINE__)
/*********************************************************************
NOTE: Use the corresponding macros instead of this function. Creates a
memory heap. For debugging purposes, takes also the file name and line as
......@@ -130,37 +118,6 @@ mem_heap_free_func(
mem_heap_t* heap, /* in, own: heap to be freed */
const char* file_name, /* in: file name where freed */
ulint line); /* in: line where freed */
/*********************************************************************
NOTE: Use the corresponding macros instead of this function. Creates a
memory heap. For debugging purposes, takes also the file name and line as
arguments. */
mem_heap_t*
mem_heap_create_func_noninline(
/*===========================*/
/* out, own: memory heap, NULL if
did not succeed (only possible for
MEM_HEAP_BTR_SEARCH type heaps)*/
ulint n, /* in: desired start block size,
this means that a single user buffer
of size n will fit in the block,
0 creates a default size block;
if init_block is not NULL, n tells
its size in bytes */
ulint type, /* in: heap type */
const char* file_name, /* in: file name where created */
ulint line); /* in: line where created */
/*********************************************************************
NOTE: Use the corresponding macro instead of this function. Frees the space
occupied by a memory heap. In the debug version erases the heap memory
blocks. */
void
mem_heap_free_func_noninline(
/*=========================*/
mem_heap_t* heap, /* in, own: heap to be freed */
const char* file_name, /* in: file name where freed */
ulint line); /* in: line where freed */
/*******************************************************************
Allocates and zero-fills n bytes of memory from a memory heap. */
UNIV_INLINE
......@@ -187,19 +144,6 @@ mem_heap_alloc(
ulint n); /* in: number of bytes; if the heap is allowed
to grow into the buffer pool, this must be
<= MEM_MAX_ALLOC_IN_BUF */
/*******************************************************************
Allocates n bytes of memory from a memory heap. */
void*
mem_heap_alloc_noninline(
/*=====================*/
/* out: allocated storage, NULL if did not
succeed (only possible for
MEM_HEAP_BTR_SEARCH type heaps) */
mem_heap_t* heap, /* in: memory heap */
ulint n); /* in: number of bytes; if the heap is allowed
to grow into the buffer pool, this must be
<= MEM_MAX_ALLOC_IN_BUF */
/*********************************************************************
Returns a pointer to the heap top. */
UNIV_INLINE
......@@ -226,13 +170,6 @@ mem_heap_empty(
/*===========*/
mem_heap_t* heap); /* in: heap to empty */
/*********************************************************************
Empties a memory heap. The first memory block of the heap is not freed. */
void
mem_heap_empty_noninline(
/*=====================*/
mem_heap_t* heap); /* in: heap to empty */
/*********************************************************************
Returns a pointer to the topmost element in a memory heap.
The size of the element must be given. */
UNIV_INLINE
......@@ -265,18 +202,6 @@ Macro for memory buffer allocation */
#define mem_calloc(N) memset(mem_alloc(N), 0, (N));
#define mem_alloc(N) mem_alloc_func((N), __FILE__, __LINE__)
/******************************************************************
Use this macro instead of the corresponding function!
Macro for memory buffer allocation */
#define mem_alloc_noninline(N) mem_alloc_func_noninline(\
(N), __FILE__, __LINE__)
/******************************************************************
Use this macro instead of the corresponding function!
Macro for memory buffer allocation */
#define mem_free_noninline(N) mem_free_func_noninline(\
(N), __FILE__, __LINE__)
/*******************************************************************
NOTE: Use the corresponding macro instead of this function.
Allocates a single buffer of memory from the dynamic memory of
......@@ -291,20 +216,6 @@ mem_alloc_func(
const char* file_name, /* in: file name where created */
ulint line); /* in: line where created */
/*******************************************************************
NOTE: Use the corresponding macro instead of this function.
Allocates a single buffer of memory from the dynamic memory of
the C compiler. Is like malloc of C. The buffer must be freed
with mem_free. */
void*
mem_alloc_func_noninline(
/*=====================*/
/* out, own: free storage */
ulint n, /* in: desired number of bytes */
const char* file_name, /* in: file name where created */
ulint line); /* in: line where created */
/******************************************************************
Use this macro instead of the corresponding function!
Macro for memory buffer freeing */
......@@ -322,18 +233,6 @@ mem_free_func(
const char* file_name, /* in: file name where created */
ulint line /* in: line where created */
);
/*******************************************************************
NOTE: Use the corresponding macro instead of this function.
Frees a single buffer of storage from
the dynamic memory of C compiler. Similar to free of C. */
void
mem_free_func_noninline(
/*====================*/
void* ptr, /* in, own: buffer to be freed */
const char* file_name, /* in: file name where created */
ulint line /* in: line where created */
);
/**************************************************************************
Duplicates a NUL-terminated string. */
......
include/mtr0mtr.h
View file @ 8b40a79c
......@@ -155,16 +155,6 @@ mtr_start(
the mtr handle */
mtr_t* mtr); /* in: memory buffer for the mtr buffer */
/*******************************************************************
Starts a mini-transaction and creates a mini-transaction handle
and buffer in the memory buffer given by the caller. */
mtr_t*
mtr_start_noninline(
/*================*/
/* out: mtr buffer which also acts as
the mtr handle */
mtr_t* mtr); /* in: memory buffer for the mtr buffer */
/*******************************************************************
Commits a mini-transaction. */
void
......
include/page0page.h
View file @ 8b40a79c
......@@ -604,15 +604,6 @@ page_get_free_space_of_empty(
/* out: free space */
ulint comp) /* in: nonzero=compact page format */
__attribute__((const));
/*****************************************************************
Calculates free space if a page is emptied. */
ulint
page_get_free_space_of_empty_noninline(
/*===================================*/
/* out: free space */
ulint comp) /* in: nonzero=compact page format */
__attribute__((const));
/**************************************************************
Returns the base extra size of a physical record. This is the
size of the fixed header, independent of the record size. */
......
include/srv0start.h
View file @ 8b40a79c
......@@ -89,8 +89,6 @@ void set_panic_flag_for_netware(void);
extern ibool srv_have_fullfsync;
#endif
extern ulint srv_sizeof_trx_t_in_ha_innodb_cc;
extern ibool srv_is_being_started;
extern ibool srv_startup_is_before_trx_rollback_phase;
extern ibool srv_is_being_shut_down;
......
include/sync0sync.h
View file @ 8b40a79c
......@@ -85,15 +85,6 @@ NOTE! The following macro should be used in mutex locking, not the
corresponding function. */
#define mutex_enter(M) mutex_enter_func((M), __FILE__, __LINE__)
/**********************************************************************
A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
inlining of InnoDB functions, and no inlined functions should be called from
there. That is why we need to duplicate the inlined function here. */
void
mutex_enter_noninline(
/*==================*/
mutex_t* mutex); /* in: mutex */
/******************************************************************
NOTE! The following macro should be used in mutex locking, not the
corresponding function. */
......@@ -140,13 +131,6 @@ mutex_exit(
/*=======*/
mutex_t* mutex); /* in: pointer to mutex */
/**********************************************************************
Releases a mutex. */
void
mutex_exit_noninline(
/*=================*/
mutex_t* mutex); /* in: mutex */
/**********************************************************************
Returns TRUE if no mutex or rw-lock is currently locked.
Works only in the debug version. */
......
include/trx0trx.h
View file @ 8b40a79c
......@@ -171,13 +171,6 @@ void
trx_start_if_not_started_low(
/*=========================*/
trx_t* trx); /* in: transaction */
/*****************************************************************
Starts the transaction if it is not yet started. */
void
trx_start_if_not_started_noninline(
/*===============================*/
trx_t* trx); /* in: transaction */
/********************************************************************
Commits a transaction. */
......
include/univ.i
View file @ 8b40a79c
......@@ -142,7 +142,7 @@ by one. */
/* the above option enables basic recovery debugging:
new allocated file pages are reset */
#if (!defined(UNIV_DEBUG) && !defined(INSIDE_HA_INNOBASE_CC) && !defined(UNIV_MUST_NOT_INLINE))
#if (!defined(UNIV_DEBUG) && !defined(UNIV_MUST_NOT_INLINE))
/* Definition for inline version */
#ifdef __WIN__
......
mem/mem0mem.c
View file @ 8b40a79c
......@@ -84,48 +84,6 @@ UT_LIST_BASE_NODE_T(mem_block_t) mem_block_list;
#endif
/*********************************************************************
Empties a memory heap. The first memory block of the heap is not freed. */
void
mem_heap_empty_noninline(
/*=====================*/
mem_heap_t* heap) /* in: heap to empty */
{
return(mem_heap_empty(heap));
}
/*******************************************************************
NOTE: Use the corresponding macro instead of this function.
Allocates a single buffer of memory from the dynamic memory of
the C compiler. Is like malloc of C. The buffer must be freed
with mem_free. */
void*
mem_alloc_func_noninline(
/*=====================*/
/* out, own: free storage */
ulint n, /* in: desired number of bytes */
const char* file_name, /* in: file name where created */
ulint line) /* in: line where created */
{
return(mem_alloc_func(n, file_name, line));
}
/*******************************************************************
NOTE: Use the corresponding macro instead of this function.
Frees a single buffer of storage from
the dynamic memory of C compiler. Similar to free of C. */
void
mem_free_func_noninline(
/*====================*/
void* ptr, /* in, own: buffer to be freed */
const char* file_name, /* in: file name where created */
ulint line) /* in: line where created */
{
return(mem_free_func(ptr, file_name, line));
}
/**************************************************************************
Duplicates a NUL-terminated string, allocated from a memory heap. */
......@@ -591,60 +549,3 @@ mem_validate_all_blocks(void)
mem_pool_mutex_exit();
}
#endif
/*******************************************************************
Allocates n bytes of memory from a memory heap. */
void*
mem_heap_alloc_noninline(
/*=====================*/
/* out: allocated storage, NULL if did not
succeed (only possible for
MEM_HEAP_BTR_SEARCH type heaps) */
mem_heap_t* heap, /* in: memory heap */
ulint n) /* in: number of bytes; if the heap is allowed
to grow into the buffer pool, this must be
<= MEM_MAX_ALLOC_IN_BUF */
{
return(mem_heap_alloc(heap, n));
}
/*********************************************************************
NOTE: Use the corresponding macros instead of this function. Creates a
memory heap. For debugging purposes, takes also the file name and line as
argument. */
mem_heap_t*
mem_heap_create_func_noninline(
/*===========================*/
/* out, own: memory heap, NULL if
did not succeed (only possible for
MEM_HEAP_BTR_SEARCH type heaps)*/
ulint n, /* in: desired start block size,
this means that a single user buffer
of size n will fit in the block,
0 creates a default size block;
if init_block is not NULL, n tells
its size in bytes */
ulint type, /* in: heap type */
const char* file_name, /* in: file name where created */
ulint line) /* in: line where created */
{
return(mem_heap_create_func(n, type, file_name, line));
}
/*********************************************************************
NOTE: Use the corresponding macro instead of this function. Frees the space
occupied by a memory heap. In the debug version erases the heap memory
blocks. */
void
mem_heap_free_func_noninline(
/*=========================*/
mem_heap_t* heap, /* in, own: heap to be freed */
const char* file_name __attribute__((unused)),
/* in: file name where freed */
ulint line __attribute__((unused)))
{
mem_heap_free_func(heap, file_name, line);
}
mtr/mtr0mtr.c
View file @ 8b40a79c
......@@ -17,20 +17,6 @@ Created 11/26/1995 Heikki Tuuri
#include "mtr0log.h"
#include "log0log.h"
/*******************************************************************
Starts a mini-transaction and creates a mini-transaction handle
and buffer in the memory buffer given by the caller. */
mtr_t*
mtr_start_noninline(
/*================*/
/* out: mtr buffer which also acts as
the mtr handle */
mtr_t* mtr) /* in: memory buffer for the mtr buffer */
{
return(mtr_start(mtr));
}
/*********************************************************************
Releases the item in the slot given. */
UNIV_INLINE
......
page/page0page.c
View file @ 8b40a79c
......@@ -216,18 +216,6 @@ page_set_max_trx_id(
}
}
/*****************************************************************
Calculates free space if a page is emptied. */
ulint
page_get_free_space_of_empty_noninline(
/*===================================*/
/* out: free space */
ulint comp) /* in: nonzero=compact page format */
{
return(page_get_free_space_of_empty(comp));
}
/****************************************************************
Allocates a block of memory from the heap of an index page. */
......
srv/srv0start.c
View file @ 8b40a79c
......@@ -68,8 +68,6 @@ ibool srv_have_fullfsync = FALSE;
ibool srv_start_raw_disk_in_use = FALSE;
ulint srv_sizeof_trx_t_in_ha_innodb_cc;
ibool srv_startup_is_before_trx_rollback_phase = FALSE;
ibool srv_is_being_started = FALSE;
#ifndef UNIV_HOTBACKUP
......@@ -1045,18 +1043,6 @@ innobase_start_or_create_for_mysql(void)
"InnoDB: !!!!!!!! UNIV_MEM_DEBUG switched on !!!!!!!!!\n");
#endif
if (srv_sizeof_trx_t_in_ha_innodb_cc != (ulint)sizeof(trx_t)) {
fprintf(stderr,
"InnoDB: Error: trx_t size is %lu in ha_innodb.cc"
" but %lu in srv0start.c\n"
"InnoDB: Check that pthread_mutex_t is defined"
" in the same way in these\n"
"InnoDB: compilation modules. Cannot continue.\n",
(ulong) srv_sizeof_trx_t_in_ha_innodb_cc,
(ulong) sizeof(trx_t));
return(DB_ERROR);
}
/* Since InnoDB does not currently clean up all its internal data
structures in MySQL Embedded Server Library server_end(), we
print an error message if someone tries to start up InnoDB a
......
sync/sync0sync.c
View file @ 8b40a79c
......@@ -167,30 +167,6 @@ struct sync_level_struct{
ulint level; /* level of the latch in the latching order */
};
/**********************************************************************
A noninlined function that reserves a mutex. In ha_innodb.cc we have disabled
inlining of InnoDB functions, and no inlined functions should be called from
there. That is why we need to duplicate the inlined function here. */
void
mutex_enter_noninline(
/*==================*/
mutex_t* mutex) /* in: mutex */
{
mutex_enter(mutex);
}
/**********************************************************************
Releases a mutex. */
void
mutex_exit_noninline(
/*=================*/
mutex_t* mutex) /* in: mutex */
{
mutex_exit(mutex);
}
/**********************************************************************
Creates, or rather, initializes a mutex object in a specified memory
location (which must be appropriately aligned). The mutex is initialized
......
trx/trx0trx.c
View file @ 8b40a79c
......@@ -42,17 +42,6 @@ sess_t* trx_dummy_sess = NULL;
the kernel mutex */
ulint trx_n_mysql_transactions = 0;
/*****************************************************************
Starts the transaction if it is not yet started. */
void
trx_start_if_not_started_noninline(
/*===============================*/
trx_t* trx) /* in: transaction */
{
trx_start_if_not_started(trx);
}
/*****************************************************************
Set detailed error message for the transaction. */
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7