diablodale

Hi all. In my experience, I do not think that the matrix locking mechanism is reliable or functions as documented. I continue to widen my compute approach (multiple threads), therefore important that we devs understand what Max does so that we can use other mechanism to fill gaps.

savelock = jit_object_method(in_matrix,_jit_sym_lock,1)

That is the consistent method written in the MaxAPI docs (section 22.9) and all code examples. However, there are several issues which suggest it is unreliable or is not successful in achieving what the doc writes "...so that the data and attributes will not be changed across the duration of the operation"

Imagine I have a matrix. I have allowed Max to allocate the raw matrix memory -or- I have allocated it myself and set the JIT_MATRIX_DATA_REFERENCE flag. (I suspect different behavior when the memory is not allocated by Max.) Next, image I have two threads. They are running on a CPU with multiple cores (all CPUs today) and enter a function at the same time. If I use only the above jit_object_method(jit_sym_lock) method, there is no documented Max mechanism to prevent simultaneous access/change to the raw matrix data -- therefore the matrix data will be corrupted. Please note, the below is pseudocode.

// prior to myfunc(), raw_matrix_data was initialized to contain all zeros
void myfunc() {
    long savelock = jit_object_method(my_matrix, _jit_sym_lock, 1);
    void* raw_matrix_data;
    jit_object_method(my_matrix, _jit_sym_getdata, &raw_matrix_data);
    if (!raw_matrix_data) return;
    for (size_t i=0; i < 32767; i++) {
        (int*)raw_matrix_data[i] = (int*)raw_matrix_data[i] + 1;
    }
    jit_object_method(my_matrix, _jit_sym_lock, savelock);
}

Some of the values in the matrix will be 1 and some will be 2. This is due to a lack of functionality in the _jit_sym_lock to either block or return a result which can be checked by the function to understand if it is safe to proceed/not.

Naturally, Win32 and C++ provide native locking mechanisms I can use to definitively protect. And Max has systhread_mutex_lock(). I am trying to understand the deep functionality of this documented _jit_sym_lock Max locking method so that I know when to safely use it and when I should use other mechanisms.

There is no documentation or code which indicated this API blocks. If it doesn't block, that suggests that the API needs to return a result of either "got a lock" or "request to lock failed"

There is no doc or code which discusses such a lock request result. Nothing discusses the meaning of the result savelock. Therefore, code can not check the result to understand if safe to proceed/not.

There is no doc or code which discusses this locking method in relation to multiple threads.

Some of the values in the matrix will be 1 and some will be 2. This is due to a lack of functionality in the  _jit_sym_lock to either block or return a result which can be checked by the function to understand if it is safe to proceed/not.

Hi all. In my experience, I do not think that the matrix locking mechanism is reliable or functions as documented. I continue to widen my co

locking matrices - can't verify _jit_sym_lock locks and prevents multiple access