pthreads/{array_thrsafe_mutex/array.c → array_thrsafe_perf/array_mutex.c} RENAMED
@@ -1,156 +1,156 @@
1
  #include <assert.h>
2
  #include <stdlib.h>
3
  #include <pthread.h>
4
 
5
- #include "array.h"
6
 
7
 
8
- typedef struct array
9
  {
10
  void** elements;
11
  size_t capacity;
12
  size_t count;
13
  pthread_mutex_t mutex;
14
- } array_t;
15
 
16
  // Private declarations
17
- size_t array_find_first_private(array_t* array, const void* element, size_t start_pos);
18
 
19
 
20
- array_t* array_create(size_t capacity)
21
  {
22
  assert(capacity);
23
 
24
- array_t* array = calloc(1, sizeof(array_t));
25
  if ( array == NULL )
26
  return NULL;
27
 
28
  array->capacity = capacity;
29
  array->count = 0;
30
 
31
  pthread_mutex_init( &array->mutex, NULL );
32
 
33
  array->elements = (void**)malloc( capacity * sizeof(void*) );
34
  if ( array->elements == NULL )
35
  return (void)free(array), NULL;
36
 
37
  return array;
38
  }
39
 
40
- void array_destroy(array_t* array)
41
  {
42
  assert(array);
43
 
44
  pthread_mutex_destroy(&array->mutex);
45
 
46
  free(array->elements);
47
  free(array);
48
  }
49
 
50
- int array_increase_capacity(array_t* array)
51
  {
52
  assert(array);
53
 
54
  size_t new_capacity = 10 * array->capacity;
55
  void** new_elements = (void**)realloc( array->elements, new_capacity * sizeof(void*) );
56
  if ( new_elements == NULL )
57
  return -1;
58
 
59
  array->capacity = new_capacity;
60
  array->elements = new_elements;
61
 
62
  return 0; // Success
63
  }
64
 
65
- int array_decrease_capacity(array_t* array)
66
  {
67
  assert(array);
68
 
69
  size_t new_capacity = array->capacity / 10;
70
  if ( new_capacity < 10 )
71
  return 0;
72
 
73
  void** new_elements = (void**)realloc( array->elements, new_capacity * sizeof(void*) );
74
  if ( new_elements == NULL )
75
  return -1;
76
 
77
  array->capacity = new_capacity;
78
  array->elements = new_elements;
79
 
80
  return 0; // Success
81
  }
82
 
83
- size_t array_get_count(array_t* array)
84
  {
85
  assert(array);
86
 
87
  pthread_mutex_lock( &array->mutex );
88
  size_t result = array->count;
89
  pthread_mutex_unlock( &array->mutex );
90
  return result;
91
  }
92
 
93
- void* array_get_element(array_t* array, size_t index)
94
  {
95
  assert(array);
96
- assert( index < array_get_count(array) );
97
 
98
  pthread_mutex_lock( &array->mutex );
99
  void* result = array->elements[index];
100
  pthread_mutex_unlock( &array->mutex );
101
  return result;
102
  }
103
 
104
- int array_append(array_t* array, void* element)
105
  {
106
  assert(array);
107
 
108
  pthread_mutex_lock( &array->mutex );
109
  if ( array->count == array->capacity )
110
- if ( array_increase_capacity(array) )
111
  return (void)pthread_mutex_unlock( &array->mutex ), -1;
112
 
113
  assert( array->count < array->capacity );
114
  array->elements[array->count++] = element;
115
  pthread_mutex_unlock( &array->mutex );
116
  return 0; // Success
117
  }
118
 
119
- size_t array_find_first(array_t* array, const void* element, size_t start_pos)
120
  {
121
  assert( array );
122
 
123
  pthread_mutex_lock( &array->mutex );
124
- size_t result = array_find_first_private(array, element, start_pos);
125
  pthread_mutex_unlock( &array->mutex );
126
  return result;
127
  }
128
 
129
- size_t array_find_first_private(array_t* array, const void* element, size_t start_pos)
130
  {
131
  assert( array );
132
 
133
  for ( size_t index = start_pos; index < array->count; ++index )
134
  if ( array->elements[index] == element )
135
  return index;
136
 
137
- return array_not_found;
138
  }
139
 
140
- int array_remove_first(array_t* array, const void* element, size_t start_pos)
141
  {
142
  assert( array );
143
 
144
  pthread_mutex_lock( &array->mutex );
145
- size_t index = array_find_first_private(array, element, start_pos);
146
- if ( index == array_not_found )
147
  return (void)pthread_mutex_unlock( &array->mutex ), -1;
148
 
149
  for ( --array->count; index < array->count; ++index )
150
  array->elements[index] = array->elements[index + 1];
151
  if ( array->count == array->capacity / 10 )
152
- array_decrease_capacity(array);
153
 
154
  pthread_mutex_unlock( &array->mutex );
155
  return 0; // Removed
156
  }
1
  #include <assert.h>
2
  #include <stdlib.h>
3
  #include <pthread.h>
4
 
5
+ #include "array_mutex.h"
6
 
7
 
8
+ typedef struct array_mutex
9
  {
10
  void** elements;
11
  size_t capacity;
12
  size_t count;
13
  pthread_mutex_t mutex;
14
+ } array_mutex_t;
15
 
16
  // Private declarations
17
+ size_t array_mutex_find_first_private(array_mutex_t* array, const void* element, size_t start_pos);
18
 
19
 
20
+ array_mutex_t* array_mutex_create(size_t capacity)
21
  {
22
  assert(capacity);
23
 
24
+ array_mutex_t* array = calloc(1, sizeof(array_mutex_t));
25
  if ( array == NULL )
26
  return NULL;
27
 
28
  array->capacity = capacity;
29
  array->count = 0;
30
 
31
  pthread_mutex_init( &array->mutex, NULL );
32
 
33
  array->elements = (void**)malloc( capacity * sizeof(void*) );
34
  if ( array->elements == NULL )
35
  return (void)free(array), NULL;
36
 
37
  return array;
38
  }
39
 
40
+ void array_mutex_destroy(array_mutex_t* array)
41
  {
42
  assert(array);
43
 
44
  pthread_mutex_destroy(&array->mutex);
45
 
46
  free(array->elements);
47
  free(array);
48
  }
49
 
50
+ int array_mutex_increase_capacity(array_mutex_t* array)
51
  {
52
  assert(array);
53
 
54
  size_t new_capacity = 10 * array->capacity;
55
  void** new_elements = (void**)realloc( array->elements, new_capacity * sizeof(void*) );
56
  if ( new_elements == NULL )
57
  return -1;
58
 
59
  array->capacity = new_capacity;
60
  array->elements = new_elements;
61
 
62
  return 0; // Success
63
  }
64
 
65
+ int array_mutex_decrease_capacity(array_mutex_t* array)
66
  {
67
  assert(array);
68
 
69
  size_t new_capacity = array->capacity / 10;
70
  if ( new_capacity < 10 )
71
  return 0;
72
 
73
  void** new_elements = (void**)realloc( array->elements, new_capacity * sizeof(void*) );
74
  if ( new_elements == NULL )
75
  return -1;
76
 
77
  array->capacity = new_capacity;
78
  array->elements = new_elements;
79
 
80
  return 0; // Success
81
  }
82
 
83
+ size_t array_mutex_get_count(array_mutex_t* array)
84
  {
85
  assert(array);
86
 
87
  pthread_mutex_lock( &array->mutex );
88
  size_t result = array->count;
89
  pthread_mutex_unlock( &array->mutex );
90
  return result;
91
  }
92
 
93
+ void* array_mutex_get_element(array_mutex_t* array, size_t index)
94
  {
95
  assert(array);
96
+ assert( index < array_mutex_get_count(array) );
97
 
98
  pthread_mutex_lock( &array->mutex );
99
  void* result = array->elements[index];
100
  pthread_mutex_unlock( &array->mutex );
101
  return result;
102
  }
103
 
104
+ int array_mutex_append(array_mutex_t* array, void* element)
105
  {
106
  assert(array);
107
 
108
  pthread_mutex_lock( &array->mutex );
109
  if ( array->count == array->capacity )
110
+ if ( array_mutex_increase_capacity(array) )
111
  return (void)pthread_mutex_unlock( &array->mutex ), -1;
112
 
113
  assert( array->count < array->capacity );
114
  array->elements[array->count++] = element;
115
  pthread_mutex_unlock( &array->mutex );
116
  return 0; // Success
117
  }
118
 
119
+ size_t array_mutex_find_first(array_mutex_t* array, const void* element, size_t start_pos)
120
  {
121
  assert( array );
122
 
123
  pthread_mutex_lock( &array->mutex );
124
+ size_t result = array_mutex_find_first_private(array, element, start_pos);
125
  pthread_mutex_unlock( &array->mutex );
126
  return result;
127
  }
128
 
129
+ size_t array_mutex_find_first_private(array_mutex_t* array, const void* element, size_t start_pos)
130
  {
131
  assert( array );
132
 
133
  for ( size_t index = start_pos; index < array->count; ++index )
134
  if ( array->elements[index] == element )
135
  return index;
136
 
137
+ return array_mutex_not_found;
138
  }
139
 
140
+ int array_mutex_remove_first(array_mutex_t* array, const void* element, size_t start_pos)
141
  {
142
  assert( array );
143
 
144
  pthread_mutex_lock( &array->mutex );
145
+ size_t index = array_mutex_find_first_private(array, element, start_pos);
146
+ if ( index == array_mutex_not_found )
147
  return (void)pthread_mutex_unlock( &array->mutex ), -1;
148
 
149
  for ( --array->count; index < array->count; ++index )
150
  array->elements[index] = array->elements[index + 1];
151
  if ( array->count == array->capacity / 10 )
152
+ array_mutex_decrease_capacity(array);
153
 
154
  pthread_mutex_unlock( &array->mutex );
155
  return 0; // Removed
156
  }