Skip to content
Snippets Groups Projects
Select Git revision
  • 9b26d7af29e26792abd27a8a354b7b3f30b58357
  • devel default
  • 107-compilation-error-when-building-maestro-core-on-m1-apple-processors
  • 108-implement-cpu-id-query-for-apple-m1-hardware
  • 58-scripting-interface-to-maestro-core
  • 101-need-ci-test-using-installed-maestro
  • 57-sphinx-documentation
  • 105-memory-leak-in-pm-message-envelope-handling
  • 104-permit-disabling-memory-pool
  • 103-liberl-installation-issue-on-devel
  • 94-maestro-rdma-transport-ignores-max_msg_size-2
  • main protected
  • 102-possible-race-in-check_pm_redundant_interlock-test
  • 97-check-if-shm-provider-can-be-enabled-after-libfabric-1-14-is-in-our-tree-2
  • 100-include-maestro-attributes-h-cannot-include-mamba-header-from-deps-path
  • 97-check-if-shm-provider-can-be-enabled-after-libfabric-1-14-is-in-our-tree
  • 17-job-failed-282354-needs-update-of-mio-interface-and-build-rules
  • 96-test-libfabric-update-to-1-13-or-1-14
  • feature/stop-telemetry-after-all-left
  • 94-maestro-rdma-transport-ignores-max_msg_size
  • 93-improve-performance-of-mstro_attribute_val_cmp_str
  • v0.3_rc1
  • maestro_d65
  • d65_experiments_20211113
  • v0.2
  • v0.2_rc1
  • d3.3
  • d3.3-review
  • d5.5
  • d5.5-review
  • v0.1
  • d3.2
  • d3.2-draft
  • v0.0
34 results

check_memlock.c

Blame
  • check_memlock.c 3.99 KiB
    /* -*- mode:c -*- */
    /** @file
     ** @brief check mstro_memlock
     **/
    
    /*
     * Copyright (C) 2020 HPE, HP Schweiz GmbH
     *
     * Redistribution and use in source and binary forms, with or without
     * modification, are permitted provided that the following conditions are
     * met:
     *
     * 1. Redistributions of source code must retain the above copyright
     *    notice, this list of conditions and the following disclaimer.
     *
     * 2. Redistributions in binary form must reproduce the above copyright
     *    notice, this list of conditions and the following disclaimer in the
     *    documentation and/or other materials provided with the distribution.
     *
     * 3. Neither the name of the copyright holder nor the names of its
     *    contributors may be used to endorse or promote products derived from
     *    this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
     * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
     * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
     * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     * HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     */
    
    /* needed before inclusion of cheat.h: */
    #ifndef __BASE_FILE__
    #define __BASE_FILE__ __FILE__
    #endif
    
    #include "cheat.h"
    
    #include "maestro.h"
    #include "maestro/i_memlock.h"
    #include <unistd.h>
    
    
    CHEAT_TEST(lock_unlock,
               {
                 cheat_assert(MSTRO_OK==mstro_memlock_init(2*8000));
                 void *x =malloc(8000);
                 cheat_assert(x!=NULL);
    
                 cheat_assert(MSTRO_OK==mstro_memlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memunlock(x,8000));
    
                 free(x);
               })
    
    
    CHEAT_TEST(lock_unlock_multi,
               {
                 cheat_assert(MSTRO_OK==mstro_memlock_init(2*8000));
                 void *x =malloc(8000);
                 cheat_assert(x!=NULL);
    
                 cheat_assert(MSTRO_OK==mstro_memlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memunlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memunlock(x,8000));
    
                 cheat_assert(MSTRO_OK==mstro_memlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memunlock(x,8000));
                 cheat_assert(MSTRO_OK==mstro_memunlock(x,8000));
    
                 cheat_assert(MSTRO_FAIL==mstro_memunlock(x,8000));
    
                 free(x);
               })
    
    CHEAT_TEST(lock_overlapping,
               {
                 long pagesize = sysconf(_SC_PAGESIZE);
                 void *x = malloc(3*pagesize);
                 cheat_assert(x!=NULL);
                 cheat_assert(pagesize>4);
    
                 cheat_assert(MSTRO_OK==mstro_memlock_init(4*pagesize));
    
                 /* one on the first page */
                 void *start1 = x;
                 size_t  len1 = pagesize/2;
                 /* one on the same page */
                 void *start2 = (void*)((uintptr_t)x+len1);
                 size_t  len2 = pagesize/4;
                 /* one extending into the third page */
                 void *start3 = (void*)((uintptr_t)x+len1+len2);
                 size_t  len3 = 2*pagesize;
    
                 cheat_assert(MSTRO_OK==mstro_memlock(start1, len1));
                 cheat_assert(MSTRO_OK==mstro_memlock(start2, len2));
                 cheat_assert(MSTRO_OK==mstro_memlock(start3, len3));
    
                 cheat_assert(MSTRO_OK==mstro_memunlock(start2, len2));
                 cheat_assert(MSTRO_OK==mstro_memunlock(start1, len1));
                 cheat_assert(MSTRO_OK==mstro_memunlock(start3, len3));
    
                 free(x);
    
                 
               })