This is an automated email from the ASF dual-hosted git repository.
mboehm7 pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/systemds.git
The following commit(s) were added to refs/heads/master by this push:
new ab08fc5 [MINOR] Fix various warnings (UINT handling, generics, static)
ab08fc5 is described below
commit ab08fc5f45b74f4dbd57136ec2c735b0d37cd7a6
Author: Matthias Boehm <[email protected]>
AuthorDate: Sat Oct 10 14:40:20 2020 +0200
[MINOR] Fix various warnings (UINT handling, generics, static)
---
src/main/java/org/apache/sysds/hops/LiteralOp.java | 1 +
.../sysds/parser/BuiltinFunctionExpression.java | 1 +
.../apache/sysds/runtime/data/LibTensorAgg.java | 3 +-
.../org/apache/sysds/runtime/data/TensorBlock.java | 2 +
.../apache/sysds/runtime/util/DataConverter.java | 1 +
.../functions/privacy/PrivacyPropagatorTest.java | 367 ++++++++++-----------
6 files changed, 190 insertions(+), 185 deletions(-)
diff --git a/src/main/java/org/apache/sysds/hops/LiteralOp.java
b/src/main/java/org/apache/sysds/hops/LiteralOp.java
index 31930e3..68d61e7 100644
--- a/src/main/java/org/apache/sysds/hops/LiteralOp.java
+++ b/src/main/java/org/apache/sysds/hops/LiteralOp.java
@@ -246,6 +246,7 @@ public class LiteralOp extends Hop
switch( getValueType() ) {
case BOOLEAN:
return String.valueOf(value_boolean);
+ case UINT8:
case INT32:
case INT64:
return String.valueOf(value_long);
diff --git
a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
index 088e740..7181a3e 100644
--- a/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
+++ b/src/main/java/org/apache/sysds/parser/BuiltinFunctionExpression.java
@@ -608,6 +608,7 @@ public class BuiltinFunctionExpression extends
DataIdentifier
break;
case INT64:
case INT32:
+ case UINT8:
case BOOLEAN:
output.setValueType(ValueType.INT64);
break;
diff --git a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
index 8201f1a..b2b19da 100644
--- a/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
+++ b/src/main/java/org/apache/sysds/runtime/data/LibTensorAgg.java
@@ -245,7 +245,8 @@ public class LibTensorAgg {
break;
}
case INT64:
- case INT32: {
+ case INT32:
+ case UINT8: {
DenseBlock a = in.getDenseBlock();
long sum = 0;
int[] ix = new int[a.numDims()];
diff --git a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
index ea8cb53..030209d 100644
--- a/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
+++ b/src/main/java/org/apache/sysds/runtime/data/TensorBlock.java
@@ -590,6 +590,8 @@ public class TensorBlock implements CacheBlock,
Externalizable {
long size = 8 + 1;
if (!bt.isSparse()) {
switch (bt._vt) {
+ case UINT8:
+ size += 1 * getLength(); break;
case INT32:
case FP32:
size += 4 * getLength(); break;
diff --git a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
index da2578a..9a6e761 100644
--- a/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
+++ b/src/main/java/org/apache/sysds/runtime/util/DataConverter.java
@@ -1137,6 +1137,7 @@ public class DataConverter
value = 0.0;
sb.append(dfFormat(df, value));
break;
+ case UINT8:
case INT32:
case INT64:
sb.append(tb.get(ix));
diff --git
a/src/test/java/org/apache/sysds/test/functions/privacy/PrivacyPropagatorTest.java
b/src/test/java/org/apache/sysds/test/functions/privacy/PrivacyPropagatorTest.java
index 9fbf54c..0092247 100644
---
a/src/test/java/org/apache/sysds/test/functions/privacy/PrivacyPropagatorTest.java
+++
b/src/test/java/org/apache/sysds/test/functions/privacy/PrivacyPropagatorTest.java
@@ -123,28 +123,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
mmGeneralNoFineGrainedGeneralized(constraint1, constraint2,
propagator);
}
-
- private void mmGeneralNoFineGrainedGeneralized(PrivacyConstraint
constraint1, PrivacyConstraint constraint2, MatrixMultiplicationPropagator
propagator){
- MatrixBlock inputMatrix1 = new MatrixBlock(10,20,15);
- MatrixBlock inputMatrix2 = new MatrixBlock(20,30,12);
- propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
- PrivacyConstraint mergedConstraint = propagator.propagate();
- assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
- assertFalse("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
- }
-
- private void mmPropagationPrivateGeneralized(PrivacyLevel
fineGrainedPrivacyLevel, MatrixMultiplicationPropagator propagator){
- MatrixBlock inputMatrix1 = new MatrixBlock(10,20,15);
- MatrixBlock inputMatrix2 = new MatrixBlock(20,30,12);
- PrivacyConstraint constraint1 = new
PrivacyConstraint(PrivacyLevel.Private);
- constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{3,8},new long[]{2,5}), fineGrainedPrivacyLevel);
- PrivacyConstraint constraint2 = new PrivacyConstraint();
- propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
- PrivacyConstraint mergedConstraint = propagator.propagate();
- assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
- assertFalse("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
- }
-
@Test
public void matrixMultiplicationPropagationTestPrivateGeneral(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -180,33 +158,7 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirstOptimized();
mmPropagationPrivateGeneralized(PrivacyLevel.PrivateAggregation, propagator);
}
-
- private void
mmPropagationTestPrivateFineGrainedGeneralized(MatrixMultiplicationPropagator
propagator){
- MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
- MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
- PrivacyConstraint constraint1 = new PrivacyConstraint();
- constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
- PrivacyConstraint constraint2 = new PrivacyConstraint();
- propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
- PrivacyConstraint mergedConstraint = propagator.propagate();
- assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
- assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
- assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
- Map<DataRange, PrivacyLevel> outputElement1 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,0});
- Map<DataRange, PrivacyLevel> outputElement2 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,1});
- Map<DataRange, PrivacyLevel> outputElement3 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,2});
- assertEquals(1, outputElement1.size());
- assertEquals(1, outputElement2.size());
- assertEquals(1, outputElement3.size());
- assertTrue("Privacy level of element 1 is Private",
outputElement1.containsValue(PrivacyLevel.Private));
- assertTrue("Privacy level of element 2 is Private",
outputElement2.containsValue(PrivacyLevel.Private));
- assertTrue("Privacy level of element 3 is Private",
outputElement3.containsValue(PrivacyLevel.Private));
- Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{2,0}, new long[]{3,2}));
- assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
- (!expectedEmpty.containsValue(PrivacyLevel.Private)
- &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
- }
-
+
@Test
public void matrixMultiplicationPropagationTestPrivateFineGrained(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -225,25 +177,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
mmPropagationTestPrivateFineGrainedGeneralized(propagator);
}
- private void
mmPropagationTestPrivateFineGrained2Generalized(MatrixMultiplicationPropagator
propagator){
- MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
- MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
- PrivacyConstraint constraint1 = new PrivacyConstraint();
- PrivacyConstraint constraint2 = new PrivacyConstraint();
- constraint2.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
- propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
- PrivacyConstraint mergedConstraint = propagator.propagate();
- assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
- assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
- assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
- Map<DataRange, PrivacyLevel> outputRange =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{0,0},new long[]{3,1}));
- assertTrue("Privacy level is Private",
outputRange.containsValue(PrivacyLevel.Private));
- Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{0,2}, new long[]{3,2}));
- assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
- (!expectedEmpty.containsValue(PrivacyLevel.Private)
- &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
- }
-
@Test
public void matrixMultiplicationPropagationTestPrivateFineGrained2(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -262,38 +195,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
mmPropagationTestPrivateFineGrained2Generalized(propagator);
}
- private void
mmPropagationTestPrivatePrivateAggregationFineGrainedGeneralized(MatrixMultiplicationPropagator
propagator){
- //Build
- MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
- MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
- PrivacyConstraint constraint1 = new PrivacyConstraint();
- constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
- PrivacyConstraint constraint2 = new PrivacyConstraint();
- constraint2.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.PrivateAggregation);
-
- //Execute
- propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
- PrivacyConstraint mergedConstraint = propagator.propagate();
-
- //Assert
- assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
- assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
- assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
- Map<DataRange, PrivacyLevel> outputElement1 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,0});
- Map<DataRange, PrivacyLevel> outputElement2 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,1});
- Map<DataRange, PrivacyLevel> outputElement3 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,2});
- assertEquals(1, outputElement1.size());
- assertEquals(1, outputElement2.size());
- assertEquals(1, outputElement3.size());
- assertTrue("Privacy level of element 1 is Private",
outputElement1.containsValue(PrivacyLevel.Private));
- assertTrue("Privacy level of element 2 is Private",
outputElement2.containsValue(PrivacyLevel.Private));
- assertTrue("Privacy level of element 3 is Private",
outputElement3.containsValue(PrivacyLevel.Private));
- Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{2,0}, new long[]{3,2}));
- assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
- (!expectedEmpty.containsValue(PrivacyLevel.Private)
- &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
- }
-
@Test
public void
matrixMultiplicationPropagationTestPrivatePrivateAggregationFineGrained(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -337,21 +238,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
assertEquals("All values except one should be
OperatorType.Aggregate", expected, actualArray[nonAggRow]);
}
- private void
getOperatorTypesRowMultipleNonAggTestGeneralized(MatrixMultiplicationPropagator
propagator){
- int rows = 4;
- int cols = 2;
- int nonAggRow = 2;
- MatrixBlock m1 = getMatrixBlock(rows, cols);
- // Make two rows NNZ=1
- m1.getDenseBlock().set(nonAggRow,0,0);
- m1.getDenseBlock().set(nonAggRow+1,0,0);
- propagator.setFields(m1, null, null, null);
- OperatorType[] actualArray = propagator.getOperatorTypesRow();
- OperatorType expected = OperatorType.NonAggregate;
- assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggRow]);
- assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggRow+1]);
- }
-
@Test
public void getOperatorTypesRowMultipleNonAggTest(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -384,37 +270,12 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
assertEquals("All values except one should be
OperatorType.Aggregate", expected, actualArray[nonAggCol]);
}
- private void
getOperatorTypesColMultipleNonAggTestGeneralized(MatrixMultiplicationPropagator
propagator){
- int rows = 2;
- int cols = 3;
- int nonAggCol = 1;
- MatrixBlock m2 = getMatrixBlock(rows, cols);
- // Make two cols NNZ=1
- m2.getDenseBlock().set(0,nonAggCol,0);
- m2.getDenseBlock().set(0,nonAggCol+1,0);
- propagator.setFields(null, null, m2, null);
- OperatorType[] actualArray = propagator.getOperatorTypesCol();
- OperatorType expected = OperatorType.NonAggregate;
- assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggCol]);
- assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggCol+1]);
- }
-
@Test
public void getOperatorTypesColMultipleNonAggTest(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
getOperatorTypesColMultipleNonAggTestGeneralized(propagator);
}
- private MatrixBlock getMatrixBlock(int rows, int cols){
- DenseBlock denseM = new DenseBlockLFP64(new int[]{rows,cols});
- for ( int r = 0; r < rows; r++ ){
- for ( int c = 0; c < cols; c++ ){
- denseM.set(r,c,r+c+1);
- }
- }
- return new MatrixBlock(rows,cols,denseM);
- }
-
@Test
public void matrixMultiplicationPropagationTestNonAgg(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -451,27 +312,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
NonAggGeneralizedTest(PrivacyLevel.Private, propagator);
}
- private void NonAggGeneralizedTest(PrivacyLevel privacyLevel,
MatrixMultiplicationPropagator propagator){
- int nonAggRow = 2;
- MatrixBlock m1 = getMatrixBlock(4,2);
- MatrixBlock m2 = getMatrixBlock(2, 3);
- m1.getDenseBlock().set(nonAggRow,0,0);
- PrivacyConstraint constraint1 = new PrivacyConstraint();
-
constraint1.getFineGrainedPrivacy().putRow(nonAggRow,2,privacyLevel);
- PrivacyConstraint constraint2 = new PrivacyConstraint();
- propagator.setFields(m1, constraint1, m2, constraint2);
- PrivacyConstraint mergedPrivacyConstraint =
propagator.propagate();
- Map<DataRange, PrivacyLevel> constraints =
mergedPrivacyConstraint.getFineGrainedPrivacy().getPrivacyLevel(new
DataRange(new long[]{nonAggRow,0}, new long[]{nonAggRow,1}));
- assertTrue("Output constraints should contain the privacy level
" + privacyLevel.toString(),
- constraints.containsValue(privacyLevel));
- if ( privacyLevel == PrivacyLevel.Private)
- assertFalse("Output constraints should not contain the
privacy level PrivateAggregation",
-
constraints.containsValue(PrivacyLevel.PrivateAggregation));
- else if ( privacyLevel == PrivacyLevel.PrivateAggregation )
- assertFalse("Output constraints should not contain the
privacy level Private",
-
constraints.containsValue(PrivacyLevel.Private));
- }
-
@Test
public void matrixMultiplicationPropagationTestNonAgg2(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -508,27 +348,6 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
NonAggGeneralizedColTest(PrivacyLevel.Private, propagator);
}
- private void NonAggGeneralizedColTest(PrivacyLevel privacyLevel,
MatrixMultiplicationPropagator propagator){
- int nonAggCol = 2;
- MatrixBlock m1 = getMatrixBlock(4,2);
- MatrixBlock m2 = getMatrixBlock(2, 3);
- m2.getDenseBlock().set(0,nonAggCol,0);
- PrivacyConstraint constraint1 = new PrivacyConstraint();
- PrivacyConstraint constraint2 = new PrivacyConstraint();
-
constraint2.getFineGrainedPrivacy().putCol(nonAggCol,4,privacyLevel);
- propagator.setFields(m1, constraint1, m2, constraint2);
- PrivacyConstraint mergedPrivacyConstraint =
propagator.propagate();
- Map<DataRange, PrivacyLevel> constraints =
mergedPrivacyConstraint.getFineGrainedPrivacy().getPrivacyLevel(new
DataRange(new long[]{0,nonAggCol}, new long[]{3,nonAggCol}));
- assertTrue("Output constraints should contain the privacy level
" + privacyLevel.toString(),
- constraints.containsValue(privacyLevel));
- if ( privacyLevel == PrivacyLevel.Private)
- assertFalse("Output constraints should not contain the
privacy level PrivateAggregation",
-
constraints.containsValue(PrivacyLevel.PrivateAggregation));
- else if ( privacyLevel == PrivacyLevel.PrivateAggregation )
- assertFalse("Output constraints should not contain the
privacy level Private",
-
constraints.containsValue(PrivacyLevel.Private));
- }
-
@Test
public void matrixMultiplicationPropagationTestNonAggRowColNA(){
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirst();
@@ -564,8 +383,188 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
MatrixMultiplicationPropagator propagator = new
MatrixMultiplicationPropagatorPrivateFirstOptimized();
NonAggGeneralizedRowColTest(PrivacyLevel.PrivateAggregation,
false, propagator);
}
+
+ private static void mmGeneralNoFineGrainedGeneralized(PrivacyConstraint
constraint1, PrivacyConstraint constraint2, MatrixMultiplicationPropagator
propagator){
+ MatrixBlock inputMatrix1 = new MatrixBlock(10,20,15);
+ MatrixBlock inputMatrix2 = new MatrixBlock(20,30,12);
+ propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
+ PrivacyConstraint mergedConstraint = propagator.propagate();
+ assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
+ assertFalse("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
+ }
+
+ private static void mmPropagationPrivateGeneralized(PrivacyLevel
fineGrainedPrivacyLevel, MatrixMultiplicationPropagator propagator){
+ MatrixBlock inputMatrix1 = new MatrixBlock(10,20,15);
+ MatrixBlock inputMatrix2 = new MatrixBlock(20,30,12);
+ PrivacyConstraint constraint1 = new
PrivacyConstraint(PrivacyLevel.Private);
+ constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{3,8},new long[]{2,5}), fineGrainedPrivacyLevel);
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+ propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
+ PrivacyConstraint mergedConstraint = propagator.propagate();
+ assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
+ assertFalse("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
+ }
- private void NonAggGeneralizedRowColTest(PrivacyLevel privacyLevel,
boolean putElement, MatrixMultiplicationPropagator propagator){
+ private static void
mmPropagationTestPrivateFineGrainedGeneralized(MatrixMultiplicationPropagator
propagator){
+ MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
+ MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
+ PrivacyConstraint constraint1 = new PrivacyConstraint();
+ constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+ propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
+ PrivacyConstraint mergedConstraint = propagator.propagate();
+ assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
+ assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
+ assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
+ Map<DataRange, PrivacyLevel> outputElement1 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,0});
+ Map<DataRange, PrivacyLevel> outputElement2 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,1});
+ Map<DataRange, PrivacyLevel> outputElement3 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,2});
+ assertEquals(1, outputElement1.size());
+ assertEquals(1, outputElement2.size());
+ assertEquals(1, outputElement3.size());
+ assertTrue("Privacy level of element 1 is Private",
outputElement1.containsValue(PrivacyLevel.Private));
+ assertTrue("Privacy level of element 2 is Private",
outputElement2.containsValue(PrivacyLevel.Private));
+ assertTrue("Privacy level of element 3 is Private",
outputElement3.containsValue(PrivacyLevel.Private));
+ Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{2,0}, new long[]{3,2}));
+ assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
+ (!expectedEmpty.containsValue(PrivacyLevel.Private)
+ &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
+ }
+
+ private static void
mmPropagationTestPrivatePrivateAggregationFineGrainedGeneralized(MatrixMultiplicationPropagator
propagator){
+ //Build
+ MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
+ MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
+ PrivacyConstraint constraint1 = new PrivacyConstraint();
+ constraint1.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+ constraint2.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.PrivateAggregation);
+
+ //Execute
+ propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
+ PrivacyConstraint mergedConstraint = propagator.propagate();
+
+ //Assert
+ assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
+ assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
+ assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
+ Map<DataRange, PrivacyLevel> outputElement1 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,0});
+ Map<DataRange, PrivacyLevel> outputElement2 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,1});
+ Map<DataRange, PrivacyLevel> outputElement3 =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevelOfElement(new
long[]{1,2});
+ assertEquals(1, outputElement1.size());
+ assertEquals(1, outputElement2.size());
+ assertEquals(1, outputElement3.size());
+ assertTrue("Privacy level of element 1 is Private",
outputElement1.containsValue(PrivacyLevel.Private));
+ assertTrue("Privacy level of element 2 is Private",
outputElement2.containsValue(PrivacyLevel.Private));
+ assertTrue("Privacy level of element 3 is Private",
outputElement3.containsValue(PrivacyLevel.Private));
+ Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{2,0}, new long[]{3,2}));
+ assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
+ (!expectedEmpty.containsValue(PrivacyLevel.Private)
+ &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
+ }
+
+ private static void
mmPropagationTestPrivateFineGrained2Generalized(MatrixMultiplicationPropagator
propagator){
+ MatrixBlock inputMatrix1 = new MatrixBlock(4,3,2);
+ MatrixBlock inputMatrix2 = new MatrixBlock(3,3,4);
+ PrivacyConstraint constraint1 = new PrivacyConstraint();
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+ constraint2.getFineGrainedPrivacy().put(new DataRange(new
long[]{1,0},new long[]{1,1}), PrivacyLevel.Private);
+ propagator.setFields(inputMatrix1, constraint1, inputMatrix2,
constraint2);
+ PrivacyConstraint mergedConstraint = propagator.propagate();
+ assertTrue("Privacy should be set to Private",
mergedConstraint.hasPrivateElements());
+ assertTrue("Fine grained constraint should not be propagated",
mergedConstraint.hasFineGrainedConstraints());
+ assertTrue("Merged constraint should not contain privacy level
PrivateAggregation",
mergedConstraint.getFineGrainedPrivacy().getDataRangesOfPrivacyLevel(PrivacyLevel.PrivateAggregation).length
== 0);
+ Map<DataRange, PrivacyLevel> outputRange =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{0,0},new long[]{3,1}));
+ assertTrue("Privacy level is Private",
outputRange.containsValue(PrivacyLevel.Private));
+ Map<DataRange, PrivacyLevel> expectedEmpty =
mergedConstraint.getFineGrainedPrivacy().getPrivacyLevel(new DataRange(new
long[]{0,2}, new long[]{3,2}));
+ assertTrue("Any other index has no privacy constraint",
expectedEmpty.isEmpty() ||
+ (!expectedEmpty.containsValue(PrivacyLevel.Private)
+ &&
!expectedEmpty.containsValue(PrivacyLevel.PrivateAggregation)));
+ }
+
+ private static void
getOperatorTypesRowMultipleNonAggTestGeneralized(MatrixMultiplicationPropagator
propagator){
+ int rows = 4;
+ int cols = 2;
+ int nonAggRow = 2;
+ MatrixBlock m1 = getMatrixBlock(rows, cols);
+ // Make two rows NNZ=1
+ m1.getDenseBlock().set(nonAggRow,0,0);
+ m1.getDenseBlock().set(nonAggRow+1,0,0);
+ propagator.setFields(m1, null, null, null);
+ OperatorType[] actualArray = propagator.getOperatorTypesRow();
+ OperatorType expected = OperatorType.NonAggregate;
+ assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggRow]);
+ assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggRow+1]);
+ }
+
+ private static void
getOperatorTypesColMultipleNonAggTestGeneralized(MatrixMultiplicationPropagator
propagator){
+ int rows = 2;
+ int cols = 3;
+ int nonAggCol = 1;
+ MatrixBlock m2 = getMatrixBlock(rows, cols);
+ // Make two cols NNZ=1
+ m2.getDenseBlock().set(0,nonAggCol,0);
+ m2.getDenseBlock().set(0,nonAggCol+1,0);
+ propagator.setFields(null, null, m2, null);
+ OperatorType[] actualArray = propagator.getOperatorTypesCol();
+ OperatorType expected = OperatorType.NonAggregate;
+ assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggCol]);
+ assertEquals("All values except two should be
OperatorType.Aggregate", expected, actualArray[nonAggCol+1]);
+ }
+
+ private static MatrixBlock getMatrixBlock(int rows, int cols){
+ DenseBlock denseM = new DenseBlockLFP64(new int[]{rows,cols});
+ for ( int r = 0; r < rows; r++ ){
+ for ( int c = 0; c < cols; c++ ){
+ denseM.set(r,c,r+c+1);
+ }
+ }
+ return new MatrixBlock(rows,cols,denseM);
+ }
+
+ private static void NonAggGeneralizedTest(PrivacyLevel privacyLevel,
MatrixMultiplicationPropagator propagator){
+ int nonAggRow = 2;
+ MatrixBlock m1 = getMatrixBlock(4,2);
+ MatrixBlock m2 = getMatrixBlock(2, 3);
+ m1.getDenseBlock().set(nonAggRow,0,0);
+ PrivacyConstraint constraint1 = new PrivacyConstraint();
+
constraint1.getFineGrainedPrivacy().putRow(nonAggRow,2,privacyLevel);
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+ propagator.setFields(m1, constraint1, m2, constraint2);
+ PrivacyConstraint mergedPrivacyConstraint =
propagator.propagate();
+ Map<DataRange, PrivacyLevel> constraints =
mergedPrivacyConstraint.getFineGrainedPrivacy().getPrivacyLevel(new
DataRange(new long[]{nonAggRow,0}, new long[]{nonAggRow,1}));
+ assertTrue("Output constraints should contain the privacy level
" + privacyLevel.toString(),
+ constraints.containsValue(privacyLevel));
+ if ( privacyLevel == PrivacyLevel.Private)
+ assertFalse("Output constraints should not contain the
privacy level PrivateAggregation",
+
constraints.containsValue(PrivacyLevel.PrivateAggregation));
+ else if ( privacyLevel == PrivacyLevel.PrivateAggregation )
+ assertFalse("Output constraints should not contain the
privacy level Private",
+
constraints.containsValue(PrivacyLevel.Private));
+ }
+
+ private static void NonAggGeneralizedColTest(PrivacyLevel privacyLevel,
MatrixMultiplicationPropagator propagator){
+ int nonAggCol = 2;
+ MatrixBlock m1 = getMatrixBlock(4,2);
+ MatrixBlock m2 = getMatrixBlock(2, 3);
+ m2.getDenseBlock().set(0,nonAggCol,0);
+ PrivacyConstraint constraint1 = new PrivacyConstraint();
+ PrivacyConstraint constraint2 = new PrivacyConstraint();
+
constraint2.getFineGrainedPrivacy().putCol(nonAggCol,4,privacyLevel);
+ propagator.setFields(m1, constraint1, m2, constraint2);
+ PrivacyConstraint mergedPrivacyConstraint =
propagator.propagate();
+ Map<DataRange, PrivacyLevel> constraints =
mergedPrivacyConstraint.getFineGrainedPrivacy().getPrivacyLevel(new
DataRange(new long[]{0,nonAggCol}, new long[]{3,nonAggCol}));
+ assertTrue("Output constraints should contain the privacy level
" + privacyLevel.toString(),
+ constraints.containsValue(privacyLevel));
+ if ( privacyLevel == PrivacyLevel.Private)
+ assertFalse("Output constraints should not contain the
privacy level PrivateAggregation",
+
constraints.containsValue(PrivacyLevel.PrivateAggregation));
+ else if ( privacyLevel == PrivacyLevel.PrivateAggregation )
+ assertFalse("Output constraints should not contain the
privacy level Private",
+
constraints.containsValue(PrivacyLevel.Private));
+ }
+
+ private static void NonAggGeneralizedRowColTest(PrivacyLevel
privacyLevel, boolean putElement, MatrixMultiplicationPropagator propagator){
int nonAgg = 2;
MatrixBlock m1 = getMatrixBlock(4,2);
MatrixBlock m2 = getMatrixBlock(2, 3);
@@ -583,7 +582,7 @@ public class PrivacyPropagatorTest extends
AutomatedTestBase {
int privacyLevelSum = 0;
DataRange levelRange = null;
PrivacyLevel level = PrivacyLevel.None;
- for ( Map.Entry constraint : constraints )
+ for ( Map.Entry<DataRange, PrivacyLevel> constraint :
constraints )
if ( constraint.getValue() == privacyLevel ){
privacyLevelSum++;
levelRange = (DataRange)constraint.getKey();
