From e94cb46c2219da504a559d49eeda3e4134b96453 Mon Sep 17 00:00:00 2001 From: hunt Date: Tue, 22 Mar 2005 18:36:50 +0000 Subject: *** empty log message *** --- runtime/docs/html/map_8h-source.html | 321 +++++++++++++++++++---------------- 1 file changed, 174 insertions(+), 147 deletions(-) (limited to 'runtime/docs/html/map_8h-source.html') diff --git a/runtime/docs/html/map_8h-source.html b/runtime/docs/html/map_8h-source.html index 443fb9c9..26b210d2 100644 --- a/runtime/docs/html/map_8h-source.html +++ b/runtime/docs/html/map_8h-source.html @@ -7,156 +7,183 @@
Main Page | Data Structures | Directories | File List | Data Fields | Globals | Related Pages

map.h

Go to the documentation of this file.
00001 /* -*- linux-c -*- */
 00002 /** @file map.h
-00003  * @brief Header file for maps and lists
+00003  *  @brief Header file for maps and lists
 00004  */
 00005 
 00006 #include <linux/types.h>
 00007 
-00008 /** Statistics are stored in this struct
-00009 */
-00010 typedef struct {
-00011         int64_t count;
-00012         int64_t sum;
-00013         int64_t min, max;
-00014         int64_t histogram[BUCKETS];
-00015 } stat;
-00016 
-00017 /** Keys are either longs or char *
-00018  */
-00019 union key_data {
-00020         long val;
-00021         char *str;
-00022 };
-00023 
-00024 enum keytype { NONE, LONG, STR } __attribute__ ((packed));
-00025 enum valtype { INT64, STAT, STRING, END };
-00026 
-00027 /** all map nodes have the following structure 
-00028 */
-00029 struct map_node {
-00030         struct list_head lnode;
-00031         struct hlist_node hnode;
-00032         union key_data key1;
-00033         union key_data key2;
-00034         enum keytype key1type;
-00035         enum keytype key2type;
-00036 };
-00037 
-00038 /* specific map nodes with data attached */
-00039 struct map_node_int64 {
-00040         struct map_node n;
-00041         int64_t val;
-00042 };
-00043 
-00044 struct map_node_str {
-00045         struct map_node n;
-00046         char *str;
-00047 };
-00048 
-00049 struct map_node_stat {
-00050         struct map_node n;
-00051         stat stats;
-00052 };
-00053 
-00054 /** This structure contains all information about a map.
-00055  * It is allocated once when _stp_map_new() is called.
-00056  */
-00057 struct map_root {
-00058         enum valtype type;  /** type of the values stored in the array */
-00059         int maxnum;     /** maximum number of elements allowed in the array. */
-00060 
-00061         /* current number of elements */
-00062         int num;
-00063 
-00064         /* when more than maxnum elements, wrap or discard */
-00065         int no_wrap;
-00066 
-00067         /* linked list of current entries */
-00068         struct list_head head;
-00069 
-00070         /* pool of unused entries.  Used only when entries are statically allocated */
-00071         /* at startup. */
-00072         struct list_head pool;
-00073 
-00074         /* saved key entry for lookups */
-00075         struct map_node *key;
-00076 
-00077         /* this is the creation data saved between the key functions and the */
-00078         /* set/get functions */
-00079         u_int8_t create;
-00080         enum keytype c_key1type;
-00081         enum keytype c_key2type;
-00082         struct hlist_head *c_keyhead;
-00083         union key_data c_key1;
-00084         union key_data c_key2;
-00085 
-00086         /* the hash table for this array */
-00087         struct hlist_head hashes[HASH_TABLE_SIZE];
-00088 
-00089         /* pointer to allocated memory space */
-00090         void *membuf;
-00091 };
-00092 
-00093 /** All maps are of this type.
-00094  */
-00095 typedef struct map_root *MAP;
-00096 
-00097 #define key1str(ptr) (ptr->n.key1.str)
-00098 #define key2str(ptr) (ptr->n.key2.str)
-00099 #define key1int(ptr) (ptr->n.key1.val)
-00100 #define key2int(ptr) (ptr->n.key2.val)
-00101 
-00102 #define _stp_map_key2(map, key1, key2)                          \
-00103   ({                                                            \
-00104     if (__builtin_types_compatible_p (typeof (key1), char[]))   \
-00105       if (__builtin_types_compatible_p (typeof (key2), char[])) \
-00106         _stp_map_key_str_str (map, (char *)(key1), (char *)(key2));     \
-00107       else                                                      \
-00108         _stp_map_key_str_long (map, (char *)(key1), (long)(key2));      \
-00109     else                                                        \
-00110       if (__builtin_types_compatible_p (typeof (key2), char[])) \
-00111         _stp_map_key_long_str (map, (long)(key1), (char *)(key2));      \
-00112       else                                                      \
-00113         _stp_map_key_long_long (map, (long)(key1), (long)(key2));       \
-00114   })
-00115 
-00116 #define _stp_map_key(map, key)                          \
-00117   ({                                                            \
-00118     if (__builtin_types_compatible_p (typeof (key), char[]))    \
-00119       _stp_map_key_str (map, (char *)(key));                            \
-00120     else                                                        \
-00121       _stp_map_key_long (map, (long)(key));                             \
-00122   })
-00123 
-00124 #define _stp_map_set(map, val)                          \
-00125   ({                                                            \
-00126     if (__builtin_types_compatible_p (typeof (val), char[]))    \
-00127       _stp_map_set_str (map, (char *)(val));                            \
-00128     else                                                        \
-00129       _stp_map_set_int64 (map, (int64_t)(val));                 \
-00130   })
-00131 
-00132 #define _stp_list_add(map, val)                         \
-00133   ({                                                            \
-00134     if (__builtin_types_compatible_p (typeof (val), char[]))    \
-00135       _stp_list_add_str (map, (char *)(val));                           \
-00136     else                                                        \
-00137       _stp_list_add_int64 (map, (int64_t)(val));                        \
-00138   })
-00139 
-00140 
-00141 /** Loop through all elements of a map.
-00142  * @param map 
-00143  * @param ptr pointer to a map_node_stat, map_node_int64 or map_node_str
-00144  *
-00145  * @b Example:
-00146  * @include foreach.c
-00147  */
-00148 
-00149 #define foreach(map, ptr)                               \
-00150   for (ptr = (typeof(ptr))_stp_map_start(map); ptr; \
-00151        ptr = (typeof(ptr))_stp_map_iter (map, (struct map_node *)ptr))
-00152 
+00008 /** Statistics are stored in this struct */
+00009 typedef struct {
+00010         int64_t count;
+00011         int64_t sum;
+00012         int64_t min, max;
+00013         int64_t histogram[BUCKETS];
+00014 } stat;
+00015 
+00016 /** Keys are either longs or char * */
+00017 union key_data {
+00018         long val;
+00019         char *str;
+00020 };
+00021 
+00022 /** keys can be longs or strings */
+00023 enum keytype { NONE, LONG, STR } __attribute__ ((packed));
+00024 /** values can be either int64, stats or strings */
+00025 enum valtype { INT64, STAT, STRING, END };
+00026 
+00027 
+00028 /** basic map element */
+00029 struct map_node {
+00030         /** list of other nodes in the map */
+00031         struct list_head lnode;
+00032         /** list of nodes with the same hash value */
+00033         struct hlist_node hnode; 
+00034         union key_data key1;
+00035         union key_data key2;
+00036         enum keytype key1type;
+00037         enum keytype key2type;
+00038 };
+00039 
+00040 /** map element containing int64 */
+00041 struct map_node_int64 {
+00042         struct map_node n;
+00043         int64_t val;
+00044 };
+00045 
+00046 /** map element containing string */
+00047 struct map_node_str {
+00048         struct map_node n;
+00049         char *str;
+00050 };
+00051 
+00052 /** map element containing stats */
+00053 struct map_node_stat {
+00054         struct map_node n;
+00055         stat stats;
+00056 };
+00057 
+00058 /** This structure contains all information about a map.
+00059  * It is allocated once when _stp_map_new() is called. 
+00060  */
+00061 struct map_root {
+00062         /** type of the values stored in the array */
+00063         enum valtype type;
+00064         
+00065         /** maximum number of elements allowed in the array. */
+00066         int maxnum;
+00067 
+00068         /** current number of used elements */
+00069         int num;
+00070 
+00071         /** when more than maxnum elements, wrap or discard? */
+00072         int no_wrap;
+00073 
+00074         /** linked list of current entries */
+00075         struct list_head head;
+00076 
+00077         /** pool of unused entries.  Used only when entries are statically allocated
+00078             at startup. */
+00079         struct list_head pool;
+00080 
+00081         /** saved key entry for lookups */
+00082         struct map_node *key;
+00083 
+00084         /** this is the creation data saved between the key functions and the
+00085             set/get functions 
+00086             @todo Needs to be per-cpu data for SMP support */
+00087         u_int8_t create;
+00088         enum keytype c_key1type;
+00089         enum keytype c_key2type;
+00090         struct hlist_head *c_keyhead;
+00091         union key_data c_key1;
+00092         union key_data c_key2;
+00093 
+00094         /** the hash table for this array */
+00095         struct hlist_head hashes[HASH_TABLE_SIZE];
+00096 
+00097         /** pointer to allocated memory space. Used for freeing memory. */
+00098         void *membuf;
+00099 };
+00100 
+00101 /** All maps are of this type. */
+00102 typedef struct map_root *MAP;
+00103 
+00104 /** Extracts string from key1 union */
+00105 #define key1str(ptr) (ptr->n.key1.str)
+00106 /** Extracts string from key2 union */
+00107 #define key2str(ptr) (ptr->n.key2.str)
+00108 /** Extracts int from key1 union */
+00109 #define key1int(ptr) (ptr->n.key1.val)
+00110 /** Extracts int from key2 union */
+00111 #define key2int(ptr) (ptr->n.key2.val)
+00112 
+00113 /** Macro to call the proper _stp_map_key functions based on the
+00114  * types of the arguments. 
+00115  * @note May cause compiler warning on some GCCs 
+00116  */
+00117 #define _stp_map_key2(map, key1, key2)                          \
+00118   ({                                                            \
+00119     if (__builtin_types_compatible_p (typeof (key1), char[]))   \
+00120       if (__builtin_types_compatible_p (typeof (key2), char[])) \
+00121         _stp_map_key_str_str (map, (char *)(key1), (char *)(key2));     \
+00122       else                                                      \
+00123         _stp_map_key_str_long (map, (char *)(key1), (long)(key2));      \
+00124     else                                                        \
+00125       if (__builtin_types_compatible_p (typeof (key2), char[])) \
+00126         _stp_map_key_long_str (map, (long)(key1), (char *)(key2));      \
+00127       else                                                      \
+00128         _stp_map_key_long_long (map, (long)(key1), (long)(key2));       \
+00129   })
+00130 
+00131 /** Macro to call the proper _stp_map_key function based on the
+00132  * type of the argument. 
+00133  * @note May cause compiler warning on some GCCs 
+00134  */
+00135 #define _stp_map_key(map, key)                          \
+00136   ({                                                            \
+00137     if (__builtin_types_compatible_p (typeof (key), char[]))    \
+00138       _stp_map_key_str (map, (char *)(key));                            \
+00139     else                                                        \
+00140       _stp_map_key_long (map, (long)(key));                             \
+00141   })
+00142 
+00143 /** Macro to call the proper _stp_map_set function based on the
+00144  * type of the argument. 
+00145  * @note May cause compiler warning on some GCCs 
+00146  */
+00147 #define _stp_map_set(map, val)                          \
+00148   ({                                                            \
+00149     if (__builtin_types_compatible_p (typeof (val), char[]))    \
+00150       _stp_map_set_str (map, (char *)(val));                            \
+00151     else                                                        \
+00152       _stp_map_set_int64 (map, (int64_t)(val));                 \
+00153   })
+00154 
+00155 /** Macro to call the proper _stp_list_add function based on the
+00156  * types of the argument. 
+00157  * @note May cause compiler warning on some GCCs 
+00158  */
+00159 #define _stp_list_add(map, val)                         \
+00160   ({                                                            \
+00161     if (__builtin_types_compatible_p (typeof (val), char[]))    \
+00162       _stp_list_add_str (map, (char *)(val));                           \
+00163     else                                                        \
+00164       _stp_list_add_int64 (map, (int64_t)(val));                        \
+00165   })
+00166 
+00167 
+00168 /** Loop through all elements of a map.
+00169  * @param map 
+00170  * @param ptr pointer to a map_node_stat, map_node_int64 or map_node_str
+00171  *
+00172  * @b Example:
+00173  * @include foreach.c
+00174  */
+00175 
+00176 #define foreach(map, ptr)                               \
+00177   for (ptr = (typeof(ptr))_stp_map_start(map); ptr; \
+00178        ptr = (typeof(ptr))_stp_map_iter (map, (struct map_node *)ptr))
+00179
-Generated on Tue Mar 22 00:32:02 2005 for SystemTap. +Generated on Tue Mar 22 10:27:36 2005 for SystemTap. -- cgit