andre/CPipe
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

logging and state implemented

Browse Source
This commit is contained in:
Andre Heber
2016-03-03 23:17:56 +01:00
parent 2d403d66f7
commit 4b596132fb
2 changed files with 117 additions and 110 deletions
Download Patch File Download Diff File Expand all files Collapse all files

147
Pipe/main.c
View File

@@ -5,106 +5,109 @@
void increment(pipe_t * const p) void increment(pipe_t * const p)
{ {
while (Pipe_isFilled(p)) while (Pipe_isFilled(p))
{ {
uint32_t item = Pipe_Read(p); uint32_t item = Pipe_Read(p);
item++; item++;
Pipe_Write(p, item); Pipe_Write(p, item);
} }
} }
void square(pipe_t * const p) void square(pipe_t * const p)
{ {
while (Pipe_isFilled(p)) while (Pipe_isFilled(p))
{ {
uint32_t item = Pipe_Read(p); uint32_t item = Pipe_Read(p);
item = item * item; item = item * item;
Pipe_Write(p, item); Pipe_Write(p, item);
} }
} }
void integrate(pipe_t * const p) void integrate(pipe_t * const p)
{ {
static uint32_t state = 0; uint32_t * state = p->state;
while (Pipe_isFilled(p)) while (Pipe_isFilled(p))
{ {
uint32_t item = Pipe_Read(p); uint32_t item = Pipe_Read(p);
state = state + item; *state = *state + item;
Pipe_Write(p, state); Pipe_Write(p, *state);
} }
} }
void sum(pipe_t * const p) void sum(pipe_t * const p)
{ {
uint32_t sum = 0; uint32_t sum = 0;
while (Pipe_isFilled(p)) while (Pipe_isFilled(p))
sum += Pipe_Read(p); sum += Pipe_Read(p);
Pipe_Write(p, sum); Pipe_Write(p, sum);
} }
void average(pipe_t * const p) void average(pipe_t * const p)
{ {
uint32_t sum = 0; uint32_t sum = 0;
uint32_t element_counter = 0; uint32_t element_counter = 0;
uint32_t average = 0; uint32_t average = 0;
while (Pipe_isFilled(p)) while (Pipe_isFilled(p))
{ {
sum += Pipe_Read(p); sum += Pipe_Read(p);
element_counter++; element_counter++;
} }
average = sum / element_counter; average = sum / element_counter;
Pipe_Write(p, average); Pipe_Write(p, average);
}
void print(pipe_t * const p)
{
printf("\nOutput:\n");
while (Pipe_isFilled(p))
printf("%d\n", Pipe_Read(p));
}
void log(pipe_t * const from, pipe_t * const to, uint32_t elem)
{
printf("%s -> %d -> %s\n", from->name, elem, to->name);
} }
int main(int argc, char * argv[]) int main(int argc, char * argv[])
{ {
/* Create pipes and connect them */ uint32_t counter = 0;
Pipe_Create(increment_pipe, 4);
Pipe_Create(square_pipe, 4);
Pipe_Create(integrate_pipe, 8);
Pipe_Create(sum_pipe, 8);
Pipe_Create(average_pipe, 8);
Pipe_Connect(&increment_pipe, &integrate_pipe); /* Create pipes and connect them */
Pipe_Connect(&square_pipe, &integrate_pipe); Pipe_Create(increment_pipe, NULL, 4, log);
Pipe_CreateOutput(integrate_pipe, integrate_output_rb, 8); Pipe_Create(square_pipe, NULL, 4, log);
Pipe_Connect(&integrate_pipe, &sum_pipe); Pipe_Create(integrate_pipe, &counter, 8, log);
Pipe_CreateOutput(sum_pipe, sum_output_rb, 4); Pipe_Create(sum_pipe, NULL, 8, log);
Pipe_Connect(&integrate_pipe, &average_pipe); Pipe_Create(average_pipe, NULL, 8, log);
Pipe_CreateOutput(average_pipe, average_output_rb, 4); Pipe_Create(print_pipe, NULL, 4, log);
/* Generate input */ Pipe_Connect(&increment_pipe, &integrate_pipe);
Pipe_Insert(&increment_pipe, 1); Pipe_Connect(&square_pipe, &integrate_pipe);
Pipe_Insert(&increment_pipe, 3); Pipe_Connect(&integrate_pipe, &sum_pipe);
Pipe_Insert(&increment_pipe, 5); Pipe_Connect(&integrate_pipe, &average_pipe);
Pipe_Connect(&sum_pipe, &print_pipe);
Pipe_Connect(&average_pipe, &print_pipe);
Pipe_Insert(&square_pipe, 2); /* Generate input */
Pipe_Insert(&square_pipe, 4); Pipe_Insert(&increment_pipe, 1);
Pipe_Insert(&square_pipe, 6); Pipe_Insert(&increment_pipe, 3);
Pipe_Insert(&increment_pipe, 5);
/* run the functions */ Pipe_Insert(&square_pipe, 2);
increment(&increment_pipe); Pipe_Insert(&square_pipe, 4);
square(&square_pipe); Pipe_Insert(&square_pipe, 6);
integrate(&integrate_pipe);
sum(&sum_pipe);
average(&average_pipe);
/* print the output */ /* run the functions (each can run in an own thread) */
printf("Output:\n"); increment(&increment_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb)); square(&square_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb)); integrate(&integrate_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb)); sum(&sum_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb)); average(&average_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb)); print(&print_pipe);
printf("%d\n", RingBuffer_Read(&integrate_output_rb));
printf("\n");
printf("Summe: %d\n", RingBuffer_Read(&sum_output_rb));
printf("Average: %d\n", RingBuffer_Read(&average_output_rb));
getchar(); getchar();
return 0; return 0;
} }

80
Pipe/pipe.h
View File

@@ -10,55 +10,56 @@
/* number of counts */ /* number of counts */
#define PIPE_OUTPUT_COUNT 4 #define PIPE_OUTPUT_COUNT 4
typedef struct typedef struct pipe_tt
{ {
ringbuffer_t * input; ringbuffer_t * input;
ringbuffer_t *output[PIPE_OUTPUT_COUNT]; void * state;
uint8_t output_count; struct pipe_tt *output[PIPE_OUTPUT_COUNT];
uint8_t output_count;
char * name;
void(*log)(struct pipe_tt * from, struct pipe_tt * to, uint32_t elem);
} pipe_t; } pipe_t;
/***********************************/ /***********************************/
/* Functions to contruct pipe mesh */ /* Functions to contruct pipe mesh */
/***********************************/ /***********************************/
static inline void Pipe_Init(pipe_t * const p, ringbuffer_t * const arg_input)
{
p->input = arg_input;
for (uint8_t i = 0; i < PIPE_OUTPUT_COUNT; i++)
p->output[i] = NULL;
p->output_count = 0;
}
static inline void Pipe_Connect(pipe_t * const a, pipe_t * const b)
{
a->output[a->output_count] = b->input;
a->output_count++;
}
static inline void Pipe_AddOutput(pipe_t * const p, ringbuffer_t * const rb)
{
p->output[p->output_count] = rb;
p->output_count++;
}
#define Concat2(a, b) a ## b #define Concat2(a, b) a ## b
#define Concat(a, b) Concat2(a, b) #define Concat(a, b) Concat2(a, b)
#define SizeOfArray(arg) ( sizeof(arg) / sizeof(arg[0]) ) #define SizeOfArray(arg) ( sizeof(arg) / sizeof(arg[0]) )
#define Pipe_Create(arg_name, arg_size) \ #define Pipe_Create(arg_name, arg_state, arg_size, arg_log) \
static uint32_t Concat(buffer, __LINE__)[arg_size]; \ static uint32_t Concat(buffer, __LINE__)[arg_size]; \
ringbuffer_t arg_name ## _rb; \ ringbuffer_t arg_name ## _rb; \
RingBuffer_InitFromArray(&arg_name ## _rb, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \ RingBuffer_InitFromArray(&arg_name ## _rb, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \
pipe_t arg_name; \ pipe_t arg_name; \
Pipe_Init(&arg_name, &arg_name ## _rb) Pipe_Init(&arg_name, &arg_name ## _rb, arg_state, #arg_name, arg_log)
#define Pipe_CreateOutput(arg_pipe, arg_name, arg_size) \ static inline void Pipe_Init(
static uint32_t Concat(buffer, __LINE__)[arg_size]; \ pipe_t * const p,
ringbuffer_t arg_name; \ ringbuffer_t * const arg_input,
RingBuffer_InitFromArray(&arg_name, Concat(buffer, __LINE__), SizeOfArray(Concat(buffer, __LINE__))); \ void * arg_state,
Pipe_AddOutput(&arg_pipe, &arg_name); char * const arg_name,
void(*arg_log)(struct pipe_tt * from, struct pipe_tt * to, uint32_t elem)
)
{
p->input = arg_input;
p->state = arg_state;
for (uint8_t i = 0; i < PIPE_OUTPUT_COUNT; i++)
p->output[i] = NULL;
p->output_count = 0;
p->name = arg_name;
p->log = arg_log;
}
static inline void Pipe_Connect(pipe_t * const a, pipe_t * const b)
{
a->output[a->output_count] = b;
a->output_count++;
}
/************************************/ /************************************/
@@ -67,23 +68,26 @@ static inline void Pipe_AddOutput(pipe_t * const p, ringbuffer_t * const rb)
static inline void Pipe_Insert(pipe_t * const p, uint32_t elem) static inline void Pipe_Insert(pipe_t * const p, uint32_t elem)
{ {
RingBuffer_Write(p->input, elem); RingBuffer_Write(p->input, elem);
} }
static inline uint32_t Pipe_Read(pipe_t * p) static inline uint32_t Pipe_Read(pipe_t * p)
{ {
return RingBuffer_Read(p->input); return RingBuffer_Read(p->input);
} }
static inline void Pipe_Write(pipe_t * p, uint32_t elem) static inline void Pipe_Write(pipe_t * p, uint32_t elem)
{ {
for (uint8_t i = 0; i < p->output_count; i++) for (uint8_t i = 0; i < p->output_count; i++)
RingBuffer_Write(p->output[i], elem); {
p->log(p, p->output[i], elem);
RingBuffer_Write(p->output[i]->input, elem);
}
} }
static inline uint8_t Pipe_isFilled(pipe_t * p) static inline uint8_t Pipe_isFilled(pipe_t * p)
{ {
return RingBuffer_IsFilled(p->input); return RingBuffer_IsFilled(p->input);
} }
#endif #endif