how to build a simple lock (mutex) on nios II cpu

» c » how to build a simple lock (mutex) on nios II cpu

By : elian epstain

Date : November 29 2020, 09:01 AM

fixed the issue. Will look into that further It appears the Nios II architecture doesn't have atomic test-and-set instructions. Instead for synchronization of shared resources between multiple Nios II processors, the architecture uses an "Hardware Mutex Core". It works as a shared peripheral that provides an atomic test-and-test operation. You can read more about it in Altera's Creating Multiprocessor Nios II Systems Tutorial.
However, you probably don't an atomic test-and-set operation. You can make any sequence of instructions atomic with respect to interrupts on a single core system simply by disabling interrupts.

code :

Share :

how to make a mutex lock among programs, liike mutex lock among processes

By : Muhammad Irfan Malik

Date : March 29 2020, 07:55 AM

With these it helps Your idea of using a lock file is actually a fairly common idiom. It's usually used to make sure that no more than one copy of a program is running at one time. Conventionally the file is named something like ~/.foo_lock or ~/foo/.lock where foo identifies the program.
I don't remember the details of how this is generally implemented, but try man flock for a starting point. I can't recall off the top of my head the name of an open source program that does this. I think however, that gnucash would be such a program, along with numerous mail clients.

c++: spin lock or mutex comparison (simple calculations)

By : user3433270

Date : March 29 2020, 07:55 AM

this one helps. Spin lock should have better performance than mutex for simple tasks. However, in this simple test (8 threads incrementing a counter), the results shows differently: , some notes:

Why Locking in Go much slower than Java? Lot's of time spent in Mutex.Lock() Mutex.Unlock()

By : sumit

Date : March 29 2020, 07:55 AM

To fix this issue I've also posted this question on the golang-nuts group. The reply from Jesper Louis Andersen explains quite well that Java uses synchronization optimization techniques such as lock escape analysis/lock elision and lock coarsening.
Java JIT might be taking the lock and allowing multiple updates at once within the lock to increase performance. I ran the Java benchmark with -Djava.compiler=NONE which gave dramatic performance, but is not a fair comparison.

pthread_mutex_lock waiting to lock a highly contented mutex exactly 60 seconds, if the mutex cant be locked immediately

By : Kiran Yadav

Date : March 29 2020, 07:55 AM

wish of those help The problem was that, I initialized the mutex with DEFAULT_INITIALIZER using this

code :

pthread_mutex_init(&mutex, NULL);

int rc;
pthread_mutexattr_t mattr;
pthread_mutex_t mutex;
rc = pthread_mutexattr_init(&mattr);
if(rc != 0)
   perror("Error occured in mutex attr init");
rc = pthread_mutexattr_setpshared(&mattr, PTHREAD_PROCESS_SHARED);
if(rc != 0)
       perror("Error occured in pthread_mutexattr_setpshared");
pthread_mutex_init(&mutex, &mattr);

Whats better std::lock_guard<std::mutex> lock(std::mutex mutex_var); or std::mutex mutex_var.lock();

By : Paweł Ostrowski

Date : March 29 2020, 07:55 AM

hope this fix your issue You should (almost) never use std::mutex::lock(), std::mutex::try_lock() or std::mutex::unlock() directly, always use a std::lock_guard or std::unique_lock with your mutex_var. Because you don't have to write unlock, because they are doing it when they are destroyed. So you can't forget it, even if a exception has been thrown in the mean time. This is called RAII and is what you want for modern C++ code
So std::lock_guard is better