rbuf | a small circular ring buffer library in go / golang | Runtime Evironment library

I'm aware of volatile keyboard and it doesn't ensure synchronization safety.

The following code is used inside an interrupt routine, and I'm using heavily the function

GetCharUART inside the main loop.

Is it safe to and stable to write code like that ? or I have to go to low level synchronization like a mutex, if that's true, how would I protect that rbuf ?

I have to write an Erlang driver so I started by triying a little one : driverc.c , the code is simple, the Driver Erlang Data is the address of a long number and each call to the driver is to increment this number by n or multipliying this number by n, n is just one digit number (0,...., 9) and is passed as char , the code is:

I have built a device driver for an embedded board that reads and writes over a SPI bus to an external device using the spi_write_then_read() function. Performing writes works as expected. The SPI interface is a 4 bus (SCLK, CS, MOSI, MISO).

The image below shows a transaction where (SCK = SCLK, SDI = MOSI and MUXOUT = MISO)

Here's the kernel snippet for the read routine,

I have a problem in this part of code (which is common between the tasks):

I am trying to implement non-blocking communications in a large code. However, the code tends to fail for such cases. I have reproduced the error below. When running on one CPU, the code below works when switch is set to false but fails when switch is set to true.

My sorting program works fine with even number of elements in array, but gives error

" Fatal error in MPI_Gather: Message truncated, error stack: MPI_Gather(sbuf=0x00A2A700, scount=4, MPI_INT, rbuf=0x00A302C8, rcount=4, MPI_INT, root=0, MPI_COMM_WORLD) failed Message from rank 1 and tag -1342177184 truncated; 28 bytes received but buffer size is 16 "

for odd number of elements in array. The problem begins in the code if ((world_rank == 1) && (n % world_size != 0)). I tried everything and it didn't work. How can I fix this? Thanks in advance!

I have a server application serving thousands of clients for basic TCP operations. It accepts both plain text and TLS connections.

Some of the most sollicitated servers are facing a strange issue since few months. After few hours or days, there are many sockets blocked in CLOSE_WAIT state till server stop serving requests due to the lack of file descriptors.

Sockets graphs here : https://ibb.co/WsvS1D9

We tried to add logging so we can see that sockets are blocked on the first read operation (for plain text sockets) or on the handshake (for TLS) sockets. When this happens, the async_read_until and async_handshake function never finish and the associated deadline_timer callback is never called. It's like the async method is blocking the thread execution!

Connection starts from acceptor

I have enjoyed success utilizing the MySQL/Connector C libraries within my C application to manipulate a database. Use of the application, however, causes great memory usage, so much in fact that I have had to consider utilizing systemd to manage the application, which I assume will run at startup as a service since it needs to always be active. Rather than obfuscate/add complexity to this any further, I'd like to address the issue within the application.

• System: Raspberry Pi 4B
• OS: Raspbian Buster
• SQL Library: mariadb-connector-c-3.1.7
• Database: MariaDB 10.3.22 server, locally hosted

I typically clear queries that store result sets to my MYSQL_RES object using mysql_free_result(sqlRes). Inserts I keep fairly simple. Everything works correctly from a functional standpoint, but it's memory consumption is just through the roof. I am assuming a lot of this is due to my wait times in the main() looping code, but I want to be able to monitor a UART connection in nonblocking fashion with a host system that communicates at 115.2k.

Is there a best practice I am veering way off course from? A lot of my initial code was developed similar to that outlined here. I have not utilized any memory analysis applications within Raspbian as I am not too familiar with them.

Thanks

I am trying to decode RGB buffer into rows suitable for LED RGB matrix using STM32F4 (gcc in SW4STM32 IDE). The code below works perfectly when setting the compiler optimization -O0.

The code produces different result when compiling with -O1 optimization. (also -O2, -O3). The code also produces different result when adding (attribute((packed)) to struct color_t definition with -O1.

The optimization is set to this .c file only, other files are still -O0.

Could someone spot why the optimization changed code logic/behavior ?