This example shows how to create three different memory maps, and then write to each of the maps using the appropriate syntax. Then, it shows how to work with copies of your mapped data.
You can write to a file using the same MATLAB® commands
you use to access variables in the MATLAB workspace. By accessing
the Data property of the memory map, the contents
of the mapped file appear as an array in the currently active workspace.
Simply index into this array to write data to the file. The syntax
to use when writing to mapped memory depends on the format of the Data property
of the memory map.
First, create a sample file named records.dat, in your current folder.
myData = gallery('uniformdata', [5000,1], 0); fileID = fopen('records.dat','w'); fwrite(fileID, myData,'double'); fclose(fileID);
Map the file as a sequence of 16-bit-unsigned integers. Use the Format name-value pair argument to specify that the values are of type uint16.
m = memmapfile('records.dat', ... 'Offset',20, ... 'Format','uint16', ... 'Repeat',15);
Because the file is mapped as a sequence of a single class (uint16), Data is a numeric array.
Ensure that you have write permission to the mapped file. Set the Writable property of the memory map, m, to true.
m.Writable = true;
Create a matrix X that is the same size as the Data property, and write it to the mapped part of the file. All of the usual MATLAB indexing and class rules apply when assigning values to data via a memory map. The class that you assign to must be big enough to hold the value being assigned.
X = uint16(1:1:15); m.Data = X;
X is a 1-by-15 vector of integer values ranging from 1 to 15.
Verify that new values were written to the file. Specify an Offset value of 0 to begin reading from the beginning of the file. Specify a Repeat value of 35 to view a total of 35 values. Use the reshape function to display the values as a 7-by-5 matrix.
m.Offset = 0; m.Repeat = 35; reshape(m.Data,5,7)'
ans = 7x5 uint16 matrix
47662 34773 26485 16366 58664
25170 38386 16333 14934 9028
1 2 3 4 5
6 7 8 9 10
11 12 13 14 15
10085 14020 16349 37120 31342
62110 16274 9357 44395 18679
The values in X have been written to the file, records.dat .
Map a region of the file, records.dat, as a 300-by-8 matrix of type uint16 that can be referenced by the field name, x, followed by a 200-by-5 matrix of type double that can be reference by the field name, y. Specify write permission to the mapped file using the Writable name-value pair argument.
m = memmapfile('records.dat', ... 'Format', { ... 'uint16' [300 8] 'x'; ... 'double' [200 5] 'y' }, ... 'Repeat', 1, 'Writable', true);
View the Data property
m.Data
ans = struct with fields:
x: [300x8 uint16]
y: [200x5 double]
Data is a scalar structure array. This is because the file, records.dat, is mapped as containing multiple data types that do not repeat.
Replace the matrix in the field, x, with a matrix of all ones.
m.Data.x = ones(300,8,'uint16');Map the file, records.dat, as a 25-by-8 matrix of type uint16 followed by a 15-by-5 matrix of type double. Repeat the pattern 20 times.
m = memmapfile('records.dat', ... 'Format', { ... 'uint16' [5 4] 'x'; ... 'double' [15 5] 'y' }, ... 'Repeat', 20, 'Writable', true);
View the Data property
m.Data
ans=20×1 struct array with fields:
x
y
Data is a nonscalar structure array, because the file is mapped as a repeating sequence of multiple data types.
Write an array of all ones to the field named x in the 12th element of Data.
m.Data(12).x = ones(5,4,'uint16');For the 12th element of Data, write the value, 50, to all elements in rows 3 to 5 of the field, x.
m.Data(12).x(3:5,1:end) = 50;
View the field, x, of the 12th element of Data.
m.Data(12).x
ans = 5x4 uint16 matrix
1 1 1 1
1 1 1 1
50 50 50 50
50 50 50 50
50 50 50 50
The syntax to use when writing to mapped memory depends on the
format of the Data property of the memory map.
View the properties of the memory map by typing the name of the memmapfile object.
This table shows the syntaxes for writing a matrix, X,
to a memory map, m.
Format of the Data Property | Syntax for Writing to Mapped File |
|---|---|
Numeric array Example: | m.Data = X; |
Scalar (1-by-1) structure array Example: 1x1 struct array with fields:
x
y | m.Data.fieldname = X;
|
Nonscalar ( Example: 20x1 struct array with fields:
x
y | m.Data(k).fieldname = X;
|
The class of X and the number of elements
in X must match those of the Data property
or the field of the Data property being accessed.
You cannot change the dimensions of the Data property
after you have created the memory map using the memmapfile function.
For example, you cannot diminish or expand the size of an array by
removing or adding a row from the mapped array, m.Data.
If you map an entire file and then append to that file after
constructing the map, the appended data is not included in the mapped
region. If you need to modify the dimensions of data that you have
mapped to a memory map, m, you must either modify
the Format or Repeat properties
for m, or recreate m using the memmapfile function.
To successfully modify a mapped file, you must have write permission
for that file. If you do not have write permission, attempting to
write to the file generates an error, even if the Writable property
is true.
This part of the example shows how to work with copies of your mapped data. The data in variable d is a copy of the file data mapped by m.Data(2). Because it is a copy, modifying array data in d does not modify the data contained in the file.
Create a sample file named double.dat.
myData = gallery('uniformdata',[5000,1],0) * 100; fileID = fopen('double.dat','w'); fwrite(fileID,myData,'double'); fclose(fileID);
Map the file as a series of double matrices.
m = memmapfile('double.dat', ... 'Format', { ... 'double' [5 5] 'x'; ... 'double' [4 5] 'y' });
View the values in m.Data(2).x.
m.Data(2).x
ans = 5×5
50.2813 19.3431 69.7898 49.6552 66.0228
70.9471 68.2223 37.8373 89.9769 34.1971
42.8892 30.2764 86.0012 82.1629 28.9726
30.4617 54.1674 85.3655 64.4910 34.1194
18.9654 15.0873 59.3563 81.7974 53.4079
Copy the contents of m.Data to the variable, d.
d = m.Data;
Write all zeros to the field named x in the copy.
d(2).x(1:5,1:5) = 0;
Verify that zeros are written to d(2).x
d(2).x
ans = 5×5
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
0 0 0 0 0
Verify that the data in the mapped file is not changed.
m.Data(2).x
ans = 5×5
50.2813 19.3431 69.7898 49.6552 66.0228
70.9471 68.2223 37.8373 89.9769 34.1971
42.8892 30.2764 86.0012 82.1629 28.9726
30.4617 54.1674 85.3655 64.4910 34.1194
18.9654 15.0873 59.3563 81.7974 53.4079