diogo/yap-6.3
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

MYDDAS: Fix a bug on memory dealocation on MYDDAS_STATS module

Browse Source 
git-svn-id: https://yap.svn.sf.net/svnroot/yap/trunk@1669 b08c6af1-5177-4d33-ba66-4b1c6b8b522a
This commit is contained in:
tiagosoares 2006-06-06 14:11:36 +00:00
parent 93501eb171
commit 989d9579b3
14 changed files with 329 additions and 149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
C/exec.c
View File

@ -1807,8 +1807,8 @@ Yap_InitYaamRegs(void)
#ifdef CUT_C
cut_c_initialize();
#endif
#if defined CUT_C && (defined MYDDAS_ODBC || defined MYDDAS_MYSQL)
Yap_REGS.MYDDAS_GLOBAL_POINTER = myddas_util_initialize_myddas();
#if defined MYDDAS_MYSQL || defined MYDDAS_ODBC
Yap_REGS.MYDDAS_GLOBAL_POINTER = NULL;
#endif
}

2
C/init.c
View File

@ -1376,7 +1376,7 @@ Yap_exit (int value)
remove("PROFILING");
#endif
#if defined MYDDAS_MYSQL || defined MYDDAS_ODBC
Yap_MyDDAS_delete_all_myddas_structs();
Yap_MYDDAS_delete_all_myddas_structs();
#endif
if (! (Yap_PrologMode & BootMode) )
Yap_ShutdownLoadForeign();

26
H/Yapproto.h
View File

@ -10,7 +10,7 @@
* File: Yap.proto *
* mods: *
* comments: Function declarations for YAP *
* version: $Id: Yapproto.h,v 1.73 2006-04-24 12:04:21 tiagosoares Exp $ *
* version: $Id: Yapproto.h,v 1.74 2006-06-06 14:09:09 tiagosoares Exp $ *
*************************************************************************/
/* prototype file for Yap */
@ -324,25 +324,27 @@ void STD_PROTO(Yap_InitUtilCPreds,(void));
#if defined MYDDAS_MYSQL || defined MYDDAS_ODBC
/* myddas_initialization.c */
MYDDAS_GLOBAL STD_PROTO(myddas_util_initialize_myddas,(void));
MYDDAS_GLOBAL STD_PROTO(myddas_init_initialize_myddas,(void));
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_init_initialize_connection,(void *,void *,MYDDAS_UTIL_CONNECTION));
MYDDAS_UTIL_PREDICATE STD_PROTO(myddas_init_initialize_predicate,(char *, int, char *,MYDDAS_UTIL_PREDICATE));
#ifdef MYDDAS_STATS
/* myddas_statistics.c */
MYDDAS_GLOBAL STD_PROTO(myddas_stats_initialize_global_stats,(MYDDAS_GLOBAL));
MYDDAS_STATS_STRUCT STD_PROTO(myddas_stats_initialize_connection_stats,(void));
void STD_PROTO(myddas_stats_delete_stats_list,(MYDDAS_STATS_STRUCT));
#endif /* MYDDAS_STATS */
#ifdef MYDDAS_MYSQL
/* myddas_util.c */
void STD_PROTO(myddas_util_table_write,(MYSQL_RES *));
#endif
/* Returns the connection type (mysql -> 1 or odbc -> 2) */
Short STD_PROTO(myddas_util_connection_type,(void *));
/* Adds a connection identifier to the MYDDAS connections list*/
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_connection,(void *,void *));
/* Search for the node of the specified connection*/
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_search_connection,(void *));
/* Deletes a connection node from the MYDDAS connections list*/
void STD_PROTO(myddas_util_delete_connection,(void *));
/* Adds a new predicate to it's connection node list*/
MYDDAS_UTIL_CONNECTION STD_PROTO(myddas_util_add_predicate,(char * ,Int , char *,void *));
/* Search for a predicate node*/
MYDDAS_UTIL_PREDICATE STD_PROTO(myddas_util_search_predicate,(char * ,Int , char *));
/* Deletes predicate from the prediate list */
void STD_PROTO(myddas_util_delete_predicate,(MYDDAS_UTIL_PREDICATE));
/* Get's the number of queries to save */
@ -357,9 +359,9 @@ void * STD_PROTO(myddas_util_get_list_pred,(MYDDAS_UTIL_CONNECTI
void * STD_PROTO(myddas_util_get_pred_next,(void *));
char * STD_PROTO(myddas_util_get_pred_module,(void *));
char * STD_PROTO(myddas_util_get_pred_name,(void *));
Int STD_PROTO(myddas_util_get_pred_arity,(void *));
MyddasInt STD_PROTO(myddas_util_get_pred_arity,(void *));
//DELETE THIS WHEN DB_STATS IS COMPLETED
Int STD_PROTO(get_myddas_top,(void));
MyddasInt STD_PROTO(get_myddas_top,(void));
#ifdef DEBUG
void check_int(void);
@ -381,7 +383,7 @@ void STD_PROTO(Yap_InitBackMYDDAS_ODBCPreds,(void));
/* myddas_shared.c */
#if defined MYDDAS_ODBC || defined MYDDAS_MYSQL
void STD_PROTO(Yap_MyDDAS_delete_all_myddas_structs,(void));
void STD_PROTO(Yap_MYDDAS_delete_all_myddas_structs,(void));
void STD_PROTO(Yap_InitMYDDAS_SharedPreds,(void));
void STD_PROTO(Yap_InitBackMYDDAS_SharedPreds,(void));
#endif

42
MYDDAS/myddas.h
View File

@ -114,4 +114,46 @@ typedef struct myddas_global_stats *MYDDAS_GLOBAL_STATS;
typedef struct myddas_stats_struct *MYDDAS_STATS_STRUCT;
#endif
#ifdef DEBUG
#define MYDDAS_MALLOC(POINTER,TYPE) \
{ \
POINTER = (TYPE *) malloc(sizeof(TYPE)); \
Yap_REGS.MYDDAS_GLOBAL_POINTER->memory_allocated+=sizeof(TYPE); \
/*printf ("MALLOC %p %s %d\n",POINTER,__FILE__,__LINE__);*/ \
Yap_REGS.MYDDAS_GLOBAL_POINTER->malloc_called++; \
}
#else
#define MYDDAS_MALLOC(POINTER,TYPE) \
{ \
POINTER = (TYPE *) malloc(sizeof(TYPE)); \
}
#endif
#ifdef DEBUG
#define MYDDAS_FREE(POINTER,TYPE) \
{ \
Yap_REGS.MYDDAS_GLOBAL_POINTER->memory_freed+=sizeof(TYPE); \
Yap_REGS.MYDDAS_GLOBAL_POINTER->free_called++; \
/*printf ("FREE %p %s %d\n",POINTER,__FILE__,__LINE__);*/ \
free(POINTER); \
}
#else
#define MYDDAS_FREE(POINTER,TYPE) \
{ \
free(POINTER); \
}
#endif
#ifdef DEBUG
#define MYDDAS_MEMORY_MALLOC_NR(NUMBER) \
NUMBER = Yap_REGS.MYDDAS_GLOBAL_POINTER->malloc_called;
#define MYDDAS_MEMORY_MALLOC_SIZE(NUMBER) \
NUMBER = Yap_REGS.MYDDAS_GLOBAL_POINTER->memory_allocated;
#define MYDDAS_MEMORY_FREE_NR(NUMBER) \
NUMBER = Yap_REGS.MYDDAS_GLOBAL_POINTER->free_called;
#define MYDDAS_MEMORY_FREE_SIZE(NUMBER) \
NUMBER = Yap_REGS.MYDDAS_GLOBAL_POINTER->memory_freed;
#endif
#endif /*__MYDDAS_H__*/

69
MYDDAS/myddas_initialization.c
View File

@ -1,42 +1,60 @@
//* Initializes a new connection node for the MYDDAS list*/
static MYDDAS_UTIL_CONNECTION
myddas_util_initialize_connection(void *,void *,
MYDDAS_UTIL_CONNECTION);
#if defined MYDDAS_ODBC || defined MYDDAS_MYSQL
/* Initializes a new predicate node for the MYDDAS list */
static MYDDAS_UTIL_PREDICATE
myddas_util_initialize_predicate(char *, int,char *,
MYDDAS_UTIL_PREDICATE);
#include "Yap.h"
#include <stdio.h>
#include <stdlib.h>
#include "myddas.h"
#include "myddas_structs.h"
#ifdef MYDDAS_STATS
#include "myddas_statistics.h"
#endif
MYDDAS_GLOBAL
myddas_util_initialize_myddas(void){
myddas_init_initialize_myddas(void){
MYDDAS_GLOBAL global = NULL;
/* We cannot call MYDDAS_MALLOC were because the global
register isn't yet initialized */
global = (MYDDAS_GLOBAL) malloc (sizeof(struct myddas_global));
#ifdef DEBUG
printf ("MALLOC %p %s %d\n",global,__FILE__,__LINE__);
#endif
global->myddas_top_connections = NULL;
#ifdef MYDDAS_TOP_LEVEL
global->myddas_top_level_connection = NULL;
#endif
#ifdef MYDDAS_STATS
global->myddas_statistics = (MYDDAS_GLOBAL_STATS) malloc (sizeof(struct myddas_global_stats));
#ifdef DEBUG
printf ("MALLOC %p %s %d\n",global->myddas_statistics,__FILE__,__LINE__);
#endif
global->myddas_statistics->stats = NULL;
MYDDAS_STATS_INITIALIZE_GLOBAL_STATS(global->myddas_statistics->stats);
//MYDDAS_STATS_INITIALIZE_TIME_STRUCT(global->myddas_statistics->total_db_row,time_final);
//MYDDAS_STATS_INITIALIZE_TIME_STRUCT(global->myddas_statistics->total_translate,time_final);
#endif
#ifdef DEBUG
/* We first malloc for this struct and the stats struct */
#ifdef MYDDAS_STATS
global->malloc_called = 2;
global->memory_allocated = sizeof(struct myddas_global) + sizeof(struct myddas_global_stats);
#else
global->malloc_called = 1;
global->memory_allocated = sizeof(struct myddas_global);
#endif /* MYDDAS_STATS */
global->free_called = 0;
global->memory_freed = 0;
#endif
return global;
}
/* Inserts the new node on the front of the list */
static MYDDAS_UTIL_CONNECTION
myddas_util_initialize_connection(void *conn,void *enviromment,
MYDDAS_UTIL_CONNECTION
myddas_init_initialize_connection(void *conn,void *enviromment,
MYDDAS_UTIL_CONNECTION next){
MYDDAS_UTIL_CONNECTION new = malloc (sizeof(struct myddas_list_connection));
MYDDAS_UTIL_CONNECTION new = NULL;
MYDDAS_MALLOC(new,struct myddas_list_connection);
if (new == NULL)
{
return NULL;
@ -60,16 +78,18 @@ myddas_util_initialize_connection(void *conn,void *enviromment,
#ifdef MYDDAS_STATS
new->stats = NULL;
MYDDAS_STATS_INITIALIZE_CONNECTION_STATS(new->stats);
new->stats = myddas_stats_initialize_connection_stats();
#endif
return new;
}
static MYDDAS_UTIL_PREDICATE
myddas_util_initialize_predicate(char *pred_name, int pred_arity,
MYDDAS_UTIL_PREDICATE
myddas_init_initialize_predicate(char *pred_name, int pred_arity,
char *pred_module, MYDDAS_UTIL_PREDICATE next){
MYDDAS_UTIL_PREDICATE new = malloc (sizeof(struct myddas_list_preds));
MYDDAS_UTIL_PREDICATE new = NULL;
MYDDAS_MALLOC(new,struct myddas_list_preds);
if (new == NULL)
{
return NULL;
@ -89,3 +109,4 @@ myddas_util_initialize_predicate(char *pred_name, int pred_arity,
return new;
}
#endif

47
MYDDAS/myddas_mysql.c
View File

@ -187,8 +187,8 @@ c_db_my_query(void) {
MYDDAS_STATS_CON_GET_NUMBER_QUERIES_MADE_COUNT(node,count);
MYDDAS_STATS_CON_SET_NUMBER_QUERIES_MADE_COUNT(node,++count);
/* Measure time spent by the MySQL Server
processing the SQL Query */
/* Measure time spent by the MySQL Server
processing the SQL Query */
MYDDAS_STATS_TIME start,end,total_time,diff;
start = myddas_stats_walltime();
#endif
@ -211,8 +211,8 @@ c_db_my_query(void) {
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
free(end);
free(start);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_CON_GET_TOTAL_TIME_DBSERVER(node,total_time);
/* Automacally updates the MYDDAS_STRUCTURE */
@ -249,8 +249,8 @@ c_db_my_query(void) {
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
free(end);
free(start);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_CON_GET_TOTAL_TIME_TRANSFERING(node,total_time);
/* Automacally updates the MYDDAS_STRUCTURE */
@ -259,11 +259,11 @@ c_db_my_query(void) {
MYDDAS_STATS_CON_SET_TOTAL_TIME_TRANSFERING_COUNT(node,++count);
time = NULL;
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING(node,time);
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING_COUNT(node,count);
MYDDAS_STATS_CON_SET_LAST_TIME_TRANSFERING_COUNT(node,++count);
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING(node,time);
MYDDAS_STATS_CON_GET_LAST_TIME_TRANSFERING_COUNT(node,count);
MYDDAS_STATS_CON_SET_LAST_TIME_TRANSFERING_COUNT(node,++count);
myddas_stats_move_time(diff,time);
/* Measure the number of Rows returned from the server */
if (res_set != NULL)
{
@ -483,8 +483,8 @@ c_db_my_row_cut(void) {
static Int
c_db_my_row(void) {
#ifdef MYDDAS_STATS
/* Measure time used by the
c_db_my_row function */
/* Measure time used by the */
/* c_db_my_row function */
MYDDAS_STATS_TIME start,end,total_time,diff;
MyddasULInt count = 0;
start = myddas_stats_walltime();
@ -503,8 +503,8 @@ c_db_my_row(void) {
Int i, arity;
arity = IntegerOfTerm(arg_arity);
while(TRUE)
while(TRUE)
{
if ((row = mysql_fetch_row(res_set)) != NULL)
{
@ -551,22 +551,21 @@ c_db_my_row(void) {
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
free(end);
free(start);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_GET_DB_ROW_FUNCTION(total_time);
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_GET_DB_ROW_FUNCTION_COUNT(count);
MYDDAS_STATS_SET_DB_ROW_FUNCTION_COUNT(++count);
free(diff);
MYDDAS_FREE(diff,struct myddas_stats_time_struct);
#endif /* MYDDAS_STATS */
return TRUE;
}
else
{
mysql_free_result(res_set);
cut_fail();
#ifdef MYDDAS_STATS
end = myddas_stats_walltime();
@ -574,19 +573,21 @@ c_db_my_row(void) {
myddas_stats_subtract_time(diff,end,start);
diff = myddas_stats_time_copy_to_final(diff);
free(end);
free(start);
MYDDAS_FREE(end,struct myddas_stats_time_struct);
MYDDAS_FREE(start,struct myddas_stats_time_struct);
MYDDAS_STATS_GET_DB_ROW_FUNCTION(total_time);
myddas_stats_add_time(total_time,diff,total_time);
MYDDAS_STATS_GET_DB_ROW_FUNCTION_COUNT(count);
MYDDAS_STATS_SET_DB_ROW_FUNCTION_COUNT(++count);
free(diff);
MYDDAS_FREE(diff,struct myddas_stats_time_struct);
#endif /* MYDDAS_STATS */
return FALSE;
cut_fail(); /* This macro already does a return FALSE */
}
}
}
static Int
@ -714,4 +715,4 @@ c_db_my_change_database(void) {
return TRUE;
}
#endif /*MYDDAS_MYSQL*/
#endif /* MYDDAS_MYSQL */

81
MYDDAS/myddas_shared.c
View File

@ -27,7 +27,7 @@
#include "myddas_statistics.h"
#endif
//STATIC_PROTO(Int c_db_get_new_table_name,(void));
STATIC_PROTO(Int c_db_initialize_myddas,(void));
STATIC_PROTO(Int c_db_connection_type,(void));
STATIC_PROTO(Int c_db_add_preds,(void));
STATIC_PROTO(Int c_db_preds_conn_start ,(void));
@ -49,6 +49,9 @@ STATIC_PROTO(Int c_db_check,(void));
void Yap_InitMYDDAS_SharedPreds(void)
{
/* c_db_initialize_myddas */
Yap_InitCPred("c_db_initialize_myddas",0,c_db_initialize_myddas, 0);
/* c_db_connection_type: Connection x Type */
Yap_InitCPred("c_db_connection_type",2,c_db_connection_type, 0);
@ -97,6 +100,17 @@ void Yap_InitBackMYDDAS_SharedPreds(void)
}
/* Initialize all of the MYDDAS global structures */
static Int
c_db_initialize_myddas(void){
Yap_REGS.MYDDAS_GLOBAL_POINTER = myddas_init_initialize_myddas();
#ifdef MYDDAS_STATS
Yap_REGS.MYDDAS_GLOBAL_POINTER = myddas_stats_initialize_global_stats(Yap_REGS.MYDDAS_GLOBAL_POINTER);
#endif /* MYDDAS_STATS */
return TRUE;
}
/* Gives the type of a given connection,
in other words, type will be mysql or odbc
@ -357,7 +371,9 @@ c_db_stats_translate(void){
MYDDAS_STATS_GET_TRANSLATE_COUNT(count);
MYDDAS_STATS_SET_TRANSLATE_COUNT(++count);
free(diff);
MYDDAS_FREE(diff,struct myddas_stats_time_struct);
MYDDAS_FREE(start, struct myddas_stats_time_struct);
MYDDAS_FREE(end, struct myddas_stats_time_struct);
return TRUE;
#ifdef DEBUG
@ -614,7 +630,20 @@ c_db_stats(void) {
MYDDAS_STATS_PRINT_TIME_STRUCT(time);
printf ("\n\n");
#endif
/* Memory management */
#ifdef DEBUG
MyddasULInt nr;
MYDDAS_MEMORY_MALLOC_NR(nr);
printf ("Number of times malloc was called in MYDDAS: %lu \n",nr);
MYDDAS_MEMORY_FREE_NR(nr);
printf ("Number of times free was called in MYDDAS : %lu \n",nr);
MYDDAS_MEMORY_MALLOC_SIZE(nr);
printf ("Total memory allocated in MYDDAS: %lu \n",nr);
MYDDAS_MEMORY_FREE_SIZE(nr);
printf ("Total memory freed in MYDDAS : %lu \n",nr);
#endif
return TRUE;
}
@ -624,20 +653,44 @@ c_db_stats(void) {
/* Function to delete all the temporary tables */
/* from the mysql server */
void Yap_MyDDAS_delete_all_myddas_structs(void)
void Yap_MYDDAS_delete_all_myddas_structs(void)
{
//char *table_name;
//char query[500];
/* NAO ESQUECER DE FAZER ISTO TB PARA O DB_CLOSE*/
/* for(;(table_name = myddas_util_delete_all_temp_table()) != NULL ;) { */
/* printf ("%s\n",table_name); */
/* sprintf (query,"DROP TABLE IF EXISTS %s",table_name); */
/* printf ("%s\n",query); */
/* free(table_name); */
/* query[0]=0; */
/* } */
/* NAO ESQUECER DE FAZER ISTO TB PARA O DB_CLOSE*/
MYDDAS_GLOBAL global =
Yap_REGS.MYDDAS_GLOBAL_POINTER;
/* In case that the MYDDAS module isn't loaded */
if (global == NULL)
return;
MYDDAS_UTIL_CONNECTION connections =
global->myddas_top_connections;
/* Delete all connections */
for(;connections!=NULL;connections=connections->next)
myddas_util_delete_connection(connections->connection);
#ifdef MYDDAS_STATS
myddas_stats_delete_stats_list(global->myddas_statistics->stats);
MYDDAS_FREE(global->myddas_statistics,struct myddas_global_stats);
#endif
MYDDAS_FREE(global,struct myddas_global);
#ifdef DEBUG
MyddasULInt nr;
MYDDAS_MEMORY_MALLOC_NR(nr);
printf ("Number of times malloc was called in MYDDAS: %lu \n",nr);
MYDDAS_MEMORY_FREE_NR(nr);
printf ("Number of times free was called in MYDDAS : %lu \n",nr);
MYDDAS_MEMORY_MALLOC_SIZE(nr);
printf ("Total memory allocated in MYDDAS: %lu \n",nr);
MYDDAS_MEMORY_FREE_SIZE(nr);
printf ("Total memory freed in MYDDAS : %lu \n",nr);
#endif
}

113
MYDDAS/myddas_statistics.c
View File

@ -65,15 +65,19 @@ myddas_stats_integrity_of_time(MYDDAS_STATS_TIME);
MYDDAS_STATS_TIME
myddas_stats_walltime(void) {
MYDDAS_STATS_TIME myddas_time;
myddas_time = (MYDDAS_STATS_TIME) malloc (sizeof(struct timeval));
MYDDAS_STATS_TIME myddas_time = NULL;
MYDDAS_MALLOC(myddas_time,struct myddas_stats_time_struct);
myddas_time->type = time_copy;
struct timeval time;
gettimeofday(&time,NULL);
myddas_time->u.time_copy.tv_sec = time.tv_sec;
myddas_time->u.time_copy.tv_usec = time.tv_usec;
struct timeval *time = NULL;
MYDDAS_MALLOC(time,struct timeval);
gettimeofday(time,NULL);
myddas_time->u.time_copy.tv_sec = time->tv_sec;
myddas_time->u.time_copy.tv_usec = time->tv_usec;
MYDDAS_FREE(time,struct timeval);
return myddas_time;
}
@ -146,7 +150,7 @@ myddas_stats_move_time(MYDDAS_STATS_TIME from,
to->u.time_final.miliseconds = from->u.time_final.miliseconds;
to->u.time_final.microseconds = from->u.time_final.microseconds;
}
free(from);
MYDDAS_FREE(from,struct myddas_stats_time_struct);
}
MYDDAS_STATS_TIME
@ -158,7 +162,8 @@ myddas_stats_time_copy_to_final(MYDDAS_STATS_TIME t_copy){
myddas_stats_add_seconds_time(t_final,
t_copy->u.time_copy.tv_sec,
t_copy->u.time_copy.tv_usec);
free(t_copy);
MYDDAS_FREE(t_copy,struct myddas_stats_time_struct);
return t_final;
}
@ -233,6 +238,62 @@ myddas_stats_integrity_of_time(MYDDAS_STATS_TIME myddas_time){
}
}
MYDDAS_GLOBAL
myddas_stats_initialize_global_stats(MYDDAS_GLOBAL global){
MYDDAS_STATS_STRUCT stats = NULL;
short i;
/* For the time statistics */
/*
Stats [1] - Total Time spent on the db_row function
Stats [2] - Total Time spent on the translate/3 predicate
*/
/* First */
stats = myddas_stats_initialize_stat(stats,time_str);
(global->myddas_statistics)->stats = stats;
for(i=0;i<1;i++){
myddas_stats_initialize_stat(stats,time_str);
}
return global;
}
MYDDAS_STATS_STRUCT
myddas_stats_initialize_connection_stats(){
/*
Stats [1] - Total of Time Spent by the DB Server processing all the SQL Querys
Stats [2] - Total of Time Spent by the DB Server processing the last SQL Query
Stats [3] - Total of Time Spent by the DB Server transfering all the results of the SQL Querys
Stats [4] - Total of Time Spent by the DB Server transfering the result of the last SQL Query
Stats [5] - Total number of Rows returned by the server
Stats [6] - Total of Bytes Transfered by the DB Server on all SQL Querys
Stats [7] - Total of Bytes Transfered by the DB Server on the last SQL Query
Stats [8] - Number of querys made to the DBserver
*/
short i;
MYDDAS_STATS_STRUCT new = NULL ;
MYDDAS_STATS_STRUCT first;
/* For the time statistics */
/* First */
new = myddas_stats_initialize_stat(new,time_str);
first = new;
for(i=0;i<3;i++){
new = myddas_stats_initialize_stat(new,time_str);
}
/* For number statistics*/
for (i=0;i<4;i++){
new = myddas_stats_initialize_stat(new,integer);
}
return first;
}
MYDDAS_STATS_STRUCT
myddas_stats_initialize_stat(MYDDAS_STATS_STRUCT stat,int type){
@ -240,12 +301,12 @@ myddas_stats_initialize_stat(MYDDAS_STATS_STRUCT stat,int type){
MYDDAS_STATS_STRUCT temp_str = stat;
if (stat == NULL){
stat = (MYDDAS_STATS_STRUCT) malloc (sizeof(struct myddas_stats_struct));
MYDDAS_MALLOC(stat,struct myddas_stats_struct);
temp_str = stat;
} else {
for (;temp_str->next != NULL;temp_str = temp_str->next);
temp_str->next = (MYDDAS_STATS_STRUCT) malloc (sizeof(struct myddas_stats_struct));
temp_str = temp_str->next;
for (;temp_str->nxt != NULL;temp_str = temp_str->nxt);
MYDDAS_MALLOC(temp_str->nxt,struct myddas_stats_struct);
temp_str = temp_str->nxt;
}
if (type == time_str){
@ -255,7 +316,7 @@ myddas_stats_initialize_stat(MYDDAS_STATS_STRUCT stat,int type){
}
temp_str->type = type;
temp_str->count = 0;
temp_str->next = NULL;
temp_str->nxt = NULL;
return temp_str;
}
@ -265,9 +326,31 @@ myddas_stats_get_stat(MYDDAS_STATS_STRUCT stat,int index){
MYDDAS_STATS_STRUCT temp = stat;
for (;index>1;index--){
temp = temp->next;
temp = temp->nxt;
}
return temp;
}
void
myddas_stats_delete_stats_list(MYDDAS_STATS_STRUCT list){
MYDDAS_STATS_STRUCT to_delete = list;
for (;to_delete!=NULL;){
list = list->nxt;
if (to_delete->type == time_str){
MYDDAS_FREE(to_delete->u.time_str.time_str,struct myddas_stats_time_struct);
}
MYDDAS_FREE(to_delete,struct myddas_stats_struct);
to_delete = list;
}
}
#endif /* MYDDAS_STATS || MYDDAS_TOP_LEVEL */

21
MYDDAS/myddas_statistics.h
View File

@ -26,7 +26,7 @@
#endif
#define MYDDAS_STATS_INITIALIZE_TIME_STRUCT(TIME,TYPE) \
TIME = (MYDDAS_STATS_TIME) malloc (sizeof(struct myddas_stats_time_struct)); \
MYDDAS_MALLOC(TIME,struct myddas_stats_time_struct); \
\
if (TYPE == time_copy){ \
TIME->type = TYPE; \
@ -41,22 +41,6 @@
TIME->u.time_final.microseconds = 0; \
}
/*
Stats [1] - Total Time spent on the db_row function
Stats [2] - Total Time spent on the translate/3 predicate
*/
#define MYDDAS_STATS_INITIALIZE_GLOBAL_STATS(STATS) \
short i; \
\
/* For the time statistics */ \
\
/* First */ \
STATS = myddas_stats_initialize_stat(STATS,time_str); \
for(i=0;i<1;i++){ \
myddas_stats_initialize_stat(STATS,time_str); \
}
/*
Stats [1] - Total of Time Spent by the DB Server processing all the SQL Querys
Stats [2] - Total of Time Spent by the DB Server processing the last SQL Query
@ -82,7 +66,8 @@
/* For number statistics*/ \
for (i=0;i<4;i++){ \
myddas_stats_initialize_stat(STATS,integer); \
} \
}
#define MYDDAS_STATS_CON_GET_TOTAL_TIME_DBSERVER(NODE,TIME) \
TIME = myddas_stats_get_stat(NODE->stats,1)->u.time_str.time_str;

2
MYDDAS/myddas_statistics_structs.h
View File

@ -21,7 +21,7 @@ struct myddas_stats_struct{
} integer;
} u;
MyddasULInt count;
MYDDAS_STATS_STRUCT next;
MYDDAS_STATS_STRUCT nxt;
};
/* Time structure for the MYDDAS Interface */

40
MYDDAS/myddas_structs.h
View File

@ -14,6 +14,17 @@ struct myddas_global {
#ifdef MYDDAS_STATS
MYDDAS_GLOBAL_STATS myddas_statistics;
#endif
#ifdef DEBUG
/* Number times malloc was called */
MyddasULInt malloc_called;
/* Memory allocated by MYDDAS */
MyddasULInt memory_allocated;
/* Number times free was called */
MyddasULInt free_called;
/* Memory freed by MYDDAS */
MyddasULInt memory_freed;
#endif
};
struct myddas_list_preds {
@ -27,7 +38,7 @@ struct myddas_list_preds {
struct myddas_list_connection {
void *connection;
/*If variable env is NULL, then it's a
MySQL connection, if not then it as the pointer
to the ODBC enviromment variable */
@ -36,33 +47,6 @@ struct myddas_list_connection {
#ifdef MYDDAS_STATS
MYDDAS_STATS_STRUCT stats;
#endif
/* #ifdef MYDDAS_STATS */
/* /\* Total number of Rows returnes from the DataBase Server *\/ */
/* unsigned long totalNumberOfRows; */
/* /\* Total Time spent by the DataBase Server */
/* processing all querys *\/ */
/* MYDDAS_STATS_TIME totalTimeofDBServer; */
/* /\* Time spent by the DataBase Server, processing */
/* the last query *\/ */
/* MYDDAS_STATS_TIME lastTimeofDBServer; */
/* /\* Total Time spent by the DataBase Server, */
/* transfering all the data to the client *\/ */
/* MYDDAS_STATS_TIME totalFromDBServer; */
/* /\* Time spent by the DataBase Server, */
/* transfering the data of the last query *\/ */
/* MYDDAS_STATS_TIME lastFromDBServer; */
/* /\* Last bytes transfered from the server *\/ */
/* unsigned long totalBytesTransfered; */
/* /\* Total bytes transfered from the server *\/ */
/* unsigned long lastBytesTransfered; */
/* /\* Number of querys made to the Server*\/ */
/* unsigned long total_querys_made; */
/* #endif */
MYDDAS_UTIL_PREDICATE predicates;
/* Multi Queries Section */

21
MYDDAS/myddas_util.c
View File

@ -9,7 +9,6 @@
#ifdef MYDDAS_STATS
#include "myddas_statistics.h"
#endif
#include "myddas_initialization.c"
#ifdef MYDDAS_ODBC
#include <sql.h>
#endif /*MYDDAS_ODBC*/
@ -78,7 +77,7 @@ myddas_util_add_predicate(char *pred_name, Int pred_arity,
myddas_util_search_connection(con);
MYDDAS_UTIL_PREDICATE new =
myddas_util_initialize_predicate(pred_name,pred_arity,pred_module,node_con->predicates);
myddas_init_initialize_predicate(pred_name,pred_arity,pred_module,node_con->predicates);
if (new == NULL)
{
@ -105,8 +104,7 @@ myddas_util_delete_predicate(MYDDAS_UTIL_PREDICATE to_delete){
break;
con_node->predicates = to_delete->next;
}
free(to_delete);
MYDDAS_FREE(to_delete,struct myddas_list_preds);
}
void
@ -121,6 +119,10 @@ myddas_util_delete_connection(void *conn){
/* Removes the predicates list */
myddas_util_delete_predicate_list(to_delete->predicates);
#ifdef MYDDAS_STATS
/* Removes the stats list */
myddas_stats_delete_stats_list(to_delete->stats);
#endif
/* List Integrety */
/* Is the last element of the list */
if ((to_delete->next) != NULL)
@ -132,7 +134,7 @@ myddas_util_delete_connection(void *conn){
else
to_delete->previous->next=to_delete->next;
free(to_delete);
MYDDAS_FREE(to_delete,struct myddas_list_connection);
return;
}
}
@ -164,7 +166,7 @@ myddas_util_add_connection(void *conn, void *enviromment){
return node;
}
//put the new connection node on the top of the list
temp = myddas_util_initialize_connection(conn,enviromment,Yap_REGS.MYDDAS_GLOBAL_POINTER->myddas_top_connections);
temp = myddas_init_initialize_connection(conn,enviromment,Yap_REGS.MYDDAS_GLOBAL_POINTER->myddas_top_connections);
if (temp == NULL)
{
#ifdef DEBUG
@ -243,12 +245,11 @@ myddas_util_delete_predicate_list(MYDDAS_UTIL_PREDICATE preds_list){
to_delete = preds_list;
preds_list = preds_list->next;
free(to_delete);
MYDDAS_FREE(to_delete,struct myddas_list_preds);
}
return;
}
#ifdef MYDDAS_MYSQL
void
myddas_util_table_write(MYSQL_RES *res_set){
@ -319,7 +320,7 @@ myddas_util_table_write(MYSQL_RES *res_set){
#endif
//DELETE THIS WHEN DB_STATS IS COMPLETED
Int
MyddasInt
get_myddas_top(){
if (Yap_REGS.MYDDAS_GLOBAL_POINTER == NULL)
return 0;
@ -332,7 +333,7 @@ myddas_util_get_pred_next(void *pointer){
return (void *) (temp->next);
}
Int
MyddasInt
myddas_util_get_pred_arity(void *pointer){
MYDDAS_UTIL_PREDICATE temp = (MYDDAS_UTIL_PREDICATE) pointer;
return temp->pred_arity;

6
Makefile.in
View File

@ -173,6 +173,7 @@ C_SOURCES= \
$(srcdir)/MYDDAS/myddas_mysql.c \
$(srcdir)/MYDDAS/myddas_odbc.c \
$(srcdir)/MYDDAS/myddas_util.c \
$(srcdir)/MYDDAS/myddas_initialization.c \
$(srcdir)/MYDDAS/myddas_shared.c \
$(srcdir)/MYDDAS/myddas_statistics.c \
$(srcdir)/MYDDAS/myddas_top_level.c
@ -211,7 +212,7 @@ ENGINE_OBJECTS = \
exec.o gprof.o grow.o \
heapgc.o index.o init.o inlines.o \
iopreds.o depth_bound.o mavar.o \
myddas_mysql.o myddas_odbc.o myddas_shared.o \
myddas_mysql.o myddas_odbc.o myddas_shared.o myddas_initialization.o \
myddas_util.o myddas_statistics.o myddas_top_level.o modules.o other.o \
parser.o save.o scanner.o sort.o stdpreds.o sysbits.o threads.o \
tracer.o \
@ -436,6 +437,9 @@ myddas_shared.o: $(srcdir)/MYDDAS/myddas_shared.c
myddas_util.o: $(srcdir)/MYDDAS/myddas_util.c
$(CC) -c $(CFLAGS) $(srcdir)/MYDDAS/myddas_util.c -o $@
myddas_initialization.o: $(srcdir)/MYDDAS/myddas_initialization.c
$(CC) -c $(CFLAGS) $(srcdir)/MYDDAS/myddas_initialization.c -o $@
myddas_top_level.o: $(srcdir)/MYDDAS/myddas_top_level.c
$(CC) -c $(CFLAGS) $(srcdir)/MYDDAS/myddas_top_level.c -o $@

4
library/MYDDAS/myddas.ypp
View File

@ -15,6 +15,10 @@
* *
*************************************************************************/
/* Initialize MYDDAS GLOBAL STRUCTURES */
:- c_db_initialize_myddas.
:- module(myddas,[
db_open/5,
db_open/4,